﻿namespace Forms
{
    using System;
    using System.CodeDom.Compiler;
    using System.Collections;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Data;
    using System.Diagnostics;
    using System.IO;
    using System.Runtime.CompilerServices;
    using System.Runtime.Serialization;
    using System.Xml;
    using System.Xml.Schema;
    using System.Xml.Serialization;

    using Microsoft.VisualBasic.CompilerServices;

    [Serializable]
    [ToolboxItem(true)]
    [HelpKeyword("vs.data.DataSet")]
    [XmlRoot("DatenschemaBMW")]
    [DesignerCategory("code")]
    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    [XmlSchemaProvider("GetTypedDataSetSchema")]
    public class DatenschemaBMW : DataSet
    {
        #region Constants and Fields

        private SchemaSerializationMode _schemaSerializationMode;

        private DataRelation relationFK_TAB_F1_Header_TAB_F1_Detail;

        private DataRelation relationTAB_BMW_Header_TAB_BMW_Detail;

        private DataRelation relationTAB_Bestand_Header_TAB_Bestand_Details;

        private TAB_AuswertungDataTable tableTAB_Auswertung;

        private TAB_AuswertungTitleDataTable tableTAB_AuswertungTitle;

        private TAB_Auswertung_BestandDataTable tableTAB_Auswertung_Bestand;

        private TAB_BMW_Bank_DetailsDataTable tableTAB_BMW_Bank_Details;

        private TAB_BMW_Bank_Details_Alle_TMPDataTable tableTAB_BMW_Bank_Details_Alle_TMP;

        private TAB_BMW_Bank_HeaderDataTable tableTAB_BMW_Bank_Header;

        private TAB_BMW_DebitorenkontenDataTable tableTAB_BMW_Debitorenkonten;

        private TAB_BemerkungenDataTable tableTAB_Bemerkungen;

        private TAB_Bestand_DetailsDataTable tableTAB_Bestand_Details;

        private TAB_Bestand_HeaderDataTable tableTAB_Bestand_Header;

        private TAB_DauerFAsDataTable tableTAB_DauerFAs;

        private TAB_F1_DetailDataTable tableTAB_F1_Detail;

        private TAB_F1_HeaderDataTable tableTAB_F1_Header;

        private TAB_FinanzArtenDataTable tableTAB_FinanzArten;

        private TAB_HistorieDataTable tableTAB_Historie;

        #endregion

        #region Constructors and Destructors

        [DebuggerNonUserCode]
        public DatenschemaBMW()
        {
            this._schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
            this.BeginInit();
            this.InitClass();
            CollectionChangeEventHandler handler = this.SchemaChanged;
            base.Tables.CollectionChanged += handler;
            base.Relations.CollectionChanged += handler;
            this.EndInit();
        }

        [DebuggerNonUserCode]
        protected DatenschemaBMW(SerializationInfo info, StreamingContext context)
            : base(info, context, false)
        {
            this._schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
            if (this.IsBinarySerialized(info, context))
            {
                this.InitVars(false);
                CollectionChangeEventHandler handler2 = this.SchemaChanged;
                this.Tables.CollectionChanged += handler2;
                this.Relations.CollectionChanged += handler2;
            }
            else
            {
                string s = Conversions.ToString(info.GetValue("XmlSchema", typeof(string)));
                if (this.DetermineSchemaSerializationMode(info, context) == SchemaSerializationMode.IncludeSchema)
                {
                    var dataSet = new DataSet();
                    dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                    if (dataSet.Tables["TAB_F1_Header"] != null)
                    {
                        base.Tables.Add(new TAB_F1_HeaderDataTable(dataSet.Tables["TAB_F1_Header"]));
                    }
                    if (dataSet.Tables["TAB_F1_Detail"] != null)
                    {
                        base.Tables.Add(new TAB_F1_DetailDataTable(dataSet.Tables["TAB_F1_Detail"]));
                    }
                    if (dataSet.Tables["TAB_BMW_Bank_Header"] != null)
                    {
                        base.Tables.Add(new TAB_BMW_Bank_HeaderDataTable(dataSet.Tables["TAB_BMW_Bank_Header"]));
                    }
                    if (dataSet.Tables["TAB_BMW_Bank_Details"] != null)
                    {
                        base.Tables.Add(new TAB_BMW_Bank_DetailsDataTable(dataSet.Tables["TAB_BMW_Bank_Details"]));
                    }
                    if (dataSet.Tables["TAB_Auswertung"] != null)
                    {
                        base.Tables.Add(new TAB_AuswertungDataTable(dataSet.Tables["TAB_Auswertung"]));
                    }
                    if (dataSet.Tables["TAB_FinanzArten"] != null)
                    {
                        base.Tables.Add(new TAB_FinanzArtenDataTable(dataSet.Tables["TAB_FinanzArten"]));
                    }
                    if (dataSet.Tables["TAB_AuswertungTitle"] != null)
                    {
                        base.Tables.Add(new TAB_AuswertungTitleDataTable(dataSet.Tables["TAB_AuswertungTitle"]));
                    }
                    if (dataSet.Tables["TAB_Bestand_Header"] != null)
                    {
                        base.Tables.Add(new TAB_Bestand_HeaderDataTable(dataSet.Tables["TAB_Bestand_Header"]));
                    }
                    if (dataSet.Tables["TAB_Bestand_Details"] != null)
                    {
                        base.Tables.Add(new TAB_Bestand_DetailsDataTable(dataSet.Tables["TAB_Bestand_Details"]));
                    }
                    if (dataSet.Tables["TAB_Auswertung_Bestand"] != null)
                    {
                        base.Tables.Add(new TAB_Auswertung_BestandDataTable(dataSet.Tables["TAB_Auswertung_Bestand"]));
                    }
                    if (dataSet.Tables["TAB_Bemerkungen"] != null)
                    {
                        base.Tables.Add(new TAB_BemerkungenDataTable(dataSet.Tables["TAB_Bemerkungen"]));
                    }
                    if (dataSet.Tables["TAB_DauerFAs"] != null)
                    {
                        base.Tables.Add(new TAB_DauerFAsDataTable(dataSet.Tables["TAB_DauerFAs"]));
                    }
                    if (dataSet.Tables["TAB_Historie"] != null)
                    {
                        base.Tables.Add(new TAB_HistorieDataTable(dataSet.Tables["TAB_Historie"]));
                    }
                    if (dataSet.Tables["TAB_BMW_Debitorenkonten"] != null)
                    {
                        base.Tables.Add(new TAB_BMW_DebitorenkontenDataTable(dataSet.Tables["TAB_BMW_Debitorenkonten"]));
                    }
                    if (dataSet.Tables["TAB_BMW_Bank_Details_Alle_TMP"] != null)
                    {
                        base.Tables.Add(
                            new TAB_BMW_Bank_Details_Alle_TMPDataTable(dataSet.Tables["TAB_BMW_Bank_Details_Alle_TMP"]));
                    }
                    this.DataSetName = dataSet.DataSetName;
                    this.Prefix = dataSet.Prefix;
                    this.Namespace = dataSet.Namespace;
                    this.Locale = dataSet.Locale;
                    this.CaseSensitive = dataSet.CaseSensitive;
                    this.EnforceConstraints = dataSet.EnforceConstraints;
                    this.Merge(dataSet, false, MissingSchemaAction.Add);
                    this.InitVars();
                }
                else
                {
                    this.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                }
                this.GetSerializationData(info, context);
                CollectionChangeEventHandler handler = this.SchemaChanged;
                base.Tables.CollectionChanged += handler;
                this.Relations.CollectionChanged += handler;
            }
        }

        #endregion

        #region Delegates

        public delegate void TAB_AuswertungRowChangeEventHandler(object sender, TAB_AuswertungRowChangeEvent e);

        public delegate void TAB_AuswertungTitleRowChangeEventHandler(object sender, TAB_AuswertungTitleRowChangeEvent e
            );

        public delegate void TAB_Auswertung_BestandRowChangeEventHandler(
            object sender, TAB_Auswertung_BestandRowChangeEvent e);

        public delegate void TAB_BMW_Bank_DetailsRowChangeEventHandler(
            object sender, TAB_BMW_Bank_DetailsRowChangeEvent e);

        public delegate void TAB_BMW_Bank_Details_Alle_TMPRowChangeEventHandler(
            object sender, TAB_BMW_Bank_Details_Alle_TMPRowChangeEvent e);

        public delegate void TAB_BMW_Bank_HeaderRowChangeEventHandler(object sender, TAB_BMW_Bank_HeaderRowChangeEvent e
            );

        public delegate void TAB_BMW_DebitorenkontenRowChangeEventHandler(
            object sender, TAB_BMW_DebitorenkontenRowChangeEvent e);

        public delegate void TAB_BemerkungenRowChangeEventHandler(object sender, TAB_BemerkungenRowChangeEvent e);

        public delegate void TAB_Bestand_DetailsRowChangeEventHandler(object sender, TAB_Bestand_DetailsRowChangeEvent e
            );

        public delegate void TAB_Bestand_HeaderRowChangeEventHandler(object sender, TAB_Bestand_HeaderRowChangeEvent e);

        public delegate void TAB_DauerFAsRowChangeEventHandler(object sender, TAB_DauerFAsRowChangeEvent e);

        public delegate void TAB_F1_DetailRowChangeEventHandler(object sender, TAB_F1_DetailRowChangeEvent e);

        public delegate void TAB_F1_HeaderRowChangeEventHandler(object sender, TAB_F1_HeaderRowChangeEvent e);

        public delegate void TAB_FinanzArtenRowChangeEventHandler(object sender, TAB_FinanzArtenRowChangeEvent e);

        public delegate void TAB_HistorieRowChangeEventHandler(object sender, TAB_HistorieRowChangeEvent e);

        #endregion

        #region Public Properties

        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        [Browsable(true)]
        public override SchemaSerializationMode SchemaSerializationMode
        {
            get
            {
                return this._schemaSerializationMode;
            }
            set
            {
                this._schemaSerializationMode = value;
            }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [DebuggerNonUserCode]
        public TAB_AuswertungDataTable TAB_Auswertung
        {
            get
            {
                return this.tableTAB_Auswertung;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Browsable(false)]
        [DebuggerNonUserCode]
        public TAB_AuswertungTitleDataTable TAB_AuswertungTitle
        {
            get
            {
                return this.tableTAB_AuswertungTitle;
            }
        }

        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Browsable(false)]
        public TAB_Auswertung_BestandDataTable TAB_Auswertung_Bestand
        {
            get
            {
                return this.tableTAB_Auswertung_Bestand;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Browsable(false)]
        [DebuggerNonUserCode]
        public TAB_BMW_Bank_DetailsDataTable TAB_BMW_Bank_Details
        {
            get
            {
                return this.tableTAB_BMW_Bank_Details;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Browsable(false)]
        [DebuggerNonUserCode]
        public TAB_BMW_Bank_Details_Alle_TMPDataTable TAB_BMW_Bank_Details_Alle_TMP
        {
            get
            {
                return this.tableTAB_BMW_Bank_Details_Alle_TMP;
            }
        }

        [Browsable(false)]
        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TAB_BMW_Bank_HeaderDataTable TAB_BMW_Bank_Header
        {
            get
            {
                return this.tableTAB_BMW_Bank_Header;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Browsable(false)]
        [DebuggerNonUserCode]
        public TAB_BMW_DebitorenkontenDataTable TAB_BMW_Debitorenkonten
        {
            get
            {
                return this.tableTAB_BMW_Debitorenkonten;
            }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [DebuggerNonUserCode]
        public TAB_BemerkungenDataTable TAB_Bemerkungen
        {
            get
            {
                return this.tableTAB_Bemerkungen;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [DebuggerNonUserCode]
        [Browsable(false)]
        public TAB_Bestand_DetailsDataTable TAB_Bestand_Details
        {
            get
            {
                return this.tableTAB_Bestand_Details;
            }
        }

        [Browsable(false)]
        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TAB_Bestand_HeaderDataTable TAB_Bestand_Header
        {
            get
            {
                return this.tableTAB_Bestand_Header;
            }
        }

        [Browsable(false)]
        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TAB_DauerFAsDataTable TAB_DauerFAs
        {
            get
            {
                return this.tableTAB_DauerFAs;
            }
        }

        [Browsable(false)]
        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TAB_F1_DetailDataTable TAB_F1_Detail
        {
            get
            {
                return this.tableTAB_F1_Detail;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Browsable(false)]
        [DebuggerNonUserCode]
        public TAB_F1_HeaderDataTable TAB_F1_Header
        {
            get
            {
                return this.tableTAB_F1_Header;
            }
        }

        [Browsable(false)]
        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TAB_FinanzArtenDataTable TAB_FinanzArten
        {
            get
            {
                return this.tableTAB_FinanzArten;
            }
        }

        [Browsable(false)]
        [DebuggerNonUserCode]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TAB_HistorieDataTable TAB_Historie
        {
            get
            {
                return this.tableTAB_Historie;
            }
        }

        #endregion

        #region Public Methods and Operators

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
        {
            var abmw = new DatenschemaBMW();
            var type2 = new XmlSchemaComplexType();
            var sequence = new XmlSchemaSequence();
            var item = new XmlSchemaAny();
            item.Namespace = abmw.Namespace;
            sequence.Items.Add(item);
            type2.Particle = sequence;
            XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                var stream = new MemoryStream();
                var stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema)enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type2;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type2;
        }

        [DebuggerNonUserCode]
        public override DataSet Clone()
        {
            var abmw = (DatenschemaBMW)base.Clone();
            abmw.InitVars();
            abmw.SchemaSerializationMode = this.SchemaSerializationMode;
            return abmw;
        }

        #endregion

        #region Methods

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.InitVars(true);
        }

        [DebuggerNonUserCode]
        internal void InitVars(bool initTable)
        {
            this.tableTAB_F1_Header = (TAB_F1_HeaderDataTable)base.Tables["TAB_F1_Header"];
            if (initTable && (this.tableTAB_F1_Header != null))
            {
                this.tableTAB_F1_Header.InitVars();
            }
            this.tableTAB_F1_Detail = (TAB_F1_DetailDataTable)base.Tables["TAB_F1_Detail"];
            if (initTable && (this.tableTAB_F1_Detail != null))
            {
                this.tableTAB_F1_Detail.InitVars();
            }
            this.tableTAB_BMW_Bank_Header = (TAB_BMW_Bank_HeaderDataTable)base.Tables["TAB_BMW_Bank_Header"];
            if (initTable && (this.tableTAB_BMW_Bank_Header != null))
            {
                this.tableTAB_BMW_Bank_Header.InitVars();
            }
            this.tableTAB_BMW_Bank_Details = (TAB_BMW_Bank_DetailsDataTable)base.Tables["TAB_BMW_Bank_Details"];
            if (initTable && (this.tableTAB_BMW_Bank_Details != null))
            {
                this.tableTAB_BMW_Bank_Details.InitVars();
            }
            this.tableTAB_Auswertung = (TAB_AuswertungDataTable)base.Tables["TAB_Auswertung"];
            if (initTable && (this.tableTAB_Auswertung != null))
            {
                this.tableTAB_Auswertung.InitVars();
            }
            this.tableTAB_FinanzArten = (TAB_FinanzArtenDataTable)base.Tables["TAB_FinanzArten"];
            if (initTable && (this.tableTAB_FinanzArten != null))
            {
                this.tableTAB_FinanzArten.InitVars();
            }
            this.tableTAB_AuswertungTitle = (TAB_AuswertungTitleDataTable)base.Tables["TAB_AuswertungTitle"];
            if (initTable && (this.tableTAB_AuswertungTitle != null))
            {
                this.tableTAB_AuswertungTitle.InitVars();
            }
            this.tableTAB_Bestand_Header = (TAB_Bestand_HeaderDataTable)base.Tables["TAB_Bestand_Header"];
            if (initTable && (this.tableTAB_Bestand_Header != null))
            {
                this.tableTAB_Bestand_Header.InitVars();
            }
            this.tableTAB_Bestand_Details = (TAB_Bestand_DetailsDataTable)base.Tables["TAB_Bestand_Details"];
            if (initTable && (this.tableTAB_Bestand_Details != null))
            {
                this.tableTAB_Bestand_Details.InitVars();
            }
            this.tableTAB_Auswertung_Bestand = (TAB_Auswertung_BestandDataTable)base.Tables["TAB_Auswertung_Bestand"];
            if (initTable && (this.tableTAB_Auswertung_Bestand != null))
            {
                this.tableTAB_Auswertung_Bestand.InitVars();
            }
            this.tableTAB_Bemerkungen = (TAB_BemerkungenDataTable)base.Tables["TAB_Bemerkungen"];
            if (initTable && (this.tableTAB_Bemerkungen != null))
            {
                this.tableTAB_Bemerkungen.InitVars();
            }
            this.tableTAB_DauerFAs = (TAB_DauerFAsDataTable)base.Tables["TAB_DauerFAs"];
            if (initTable && (this.tableTAB_DauerFAs != null))
            {
                this.tableTAB_DauerFAs.InitVars();
            }
            this.tableTAB_Historie = (TAB_HistorieDataTable)base.Tables["TAB_Historie"];
            if (initTable && (this.tableTAB_Historie != null))
            {
                this.tableTAB_Historie.InitVars();
            }
            this.tableTAB_BMW_Debitorenkonten = (TAB_BMW_DebitorenkontenDataTable)base.Tables["TAB_BMW_Debitorenkonten"];
            if (initTable && (this.tableTAB_BMW_Debitorenkonten != null))
            {
                this.tableTAB_BMW_Debitorenkonten.InitVars();
            }
            this.tableTAB_BMW_Bank_Details_Alle_TMP =
                (TAB_BMW_Bank_Details_Alle_TMPDataTable)base.Tables["TAB_BMW_Bank_Details_Alle_TMP"];
            if (initTable && (this.tableTAB_BMW_Bank_Details_Alle_TMP != null))
            {
                this.tableTAB_BMW_Bank_Details_Alle_TMP.InitVars();
            }
            this.relationFK_TAB_F1_Header_TAB_F1_Detail = this.Relations["FK_TAB_F1_Header_TAB_F1_Detail"];
            this.relationTAB_BMW_Header_TAB_BMW_Detail = this.Relations["TAB_BMW_Header_TAB_BMW_Detail"];
            this.relationTAB_Bestand_Header_TAB_Bestand_Details =
                this.Relations["TAB_Bestand_Header_TAB_Bestand_Details"];
        }

        [DebuggerNonUserCode]
        protected override XmlSchema GetSchemaSerializable()
        {
            var w = new MemoryStream();
            this.WriteXmlSchema(new XmlTextWriter(w, null));
            w.Position = 0L;
            return XmlSchema.Read(new XmlTextReader(w), null);
        }

        [DebuggerNonUserCode]
        protected override void InitializeDerivedDataSet()
        {
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        protected override void ReadXmlSerializable(XmlReader reader)
        {
            if (this.DetermineSchemaSerializationMode(reader) == SchemaSerializationMode.IncludeSchema)
            {
                this.Reset();
                var dataSet = new DataSet();
                dataSet.ReadXml(reader);
                if (dataSet.Tables["TAB_F1_Header"] != null)
                {
                    base.Tables.Add(new TAB_F1_HeaderDataTable(dataSet.Tables["TAB_F1_Header"]));
                }
                if (dataSet.Tables["TAB_F1_Detail"] != null)
                {
                    base.Tables.Add(new TAB_F1_DetailDataTable(dataSet.Tables["TAB_F1_Detail"]));
                }
                if (dataSet.Tables["TAB_BMW_Bank_Header"] != null)
                {
                    base.Tables.Add(new TAB_BMW_Bank_HeaderDataTable(dataSet.Tables["TAB_BMW_Bank_Header"]));
                }
                if (dataSet.Tables["TAB_BMW_Bank_Details"] != null)
                {
                    base.Tables.Add(new TAB_BMW_Bank_DetailsDataTable(dataSet.Tables["TAB_BMW_Bank_Details"]));
                }
                if (dataSet.Tables["TAB_Auswertung"] != null)
                {
                    base.Tables.Add(new TAB_AuswertungDataTable(dataSet.Tables["TAB_Auswertung"]));
                }
                if (dataSet.Tables["TAB_FinanzArten"] != null)
                {
                    base.Tables.Add(new TAB_FinanzArtenDataTable(dataSet.Tables["TAB_FinanzArten"]));
                }
                if (dataSet.Tables["TAB_AuswertungTitle"] != null)
                {
                    base.Tables.Add(new TAB_AuswertungTitleDataTable(dataSet.Tables["TAB_AuswertungTitle"]));
                }
                if (dataSet.Tables["TAB_Bestand_Header"] != null)
                {
                    base.Tables.Add(new TAB_Bestand_HeaderDataTable(dataSet.Tables["TAB_Bestand_Header"]));
                }
                if (dataSet.Tables["TAB_Bestand_Details"] != null)
                {
                    base.Tables.Add(new TAB_Bestand_DetailsDataTable(dataSet.Tables["TAB_Bestand_Details"]));
                }
                if (dataSet.Tables["TAB_Auswertung_Bestand"] != null)
                {
                    base.Tables.Add(new TAB_Auswertung_BestandDataTable(dataSet.Tables["TAB_Auswertung_Bestand"]));
                }
                if (dataSet.Tables["TAB_Bemerkungen"] != null)
                {
                    base.Tables.Add(new TAB_BemerkungenDataTable(dataSet.Tables["TAB_Bemerkungen"]));
                }
                if (dataSet.Tables["TAB_DauerFAs"] != null)
                {
                    base.Tables.Add(new TAB_DauerFAsDataTable(dataSet.Tables["TAB_DauerFAs"]));
                }
                if (dataSet.Tables["TAB_Historie"] != null)
                {
                    base.Tables.Add(new TAB_HistorieDataTable(dataSet.Tables["TAB_Historie"]));
                }
                if (dataSet.Tables["TAB_BMW_Debitorenkonten"] != null)
                {
                    base.Tables.Add(new TAB_BMW_DebitorenkontenDataTable(dataSet.Tables["TAB_BMW_Debitorenkonten"]));
                }
                if (dataSet.Tables["TAB_BMW_Bank_Details_Alle_TMP"] != null)
                {
                    base.Tables.Add(
                        new TAB_BMW_Bank_Details_Alle_TMPDataTable(dataSet.Tables["TAB_BMW_Bank_Details_Alle_TMP"]));
                }
                this.DataSetName = dataSet.DataSetName;
                this.Prefix = dataSet.Prefix;
                this.Namespace = dataSet.Namespace;
                this.Locale = dataSet.Locale;
                this.CaseSensitive = dataSet.CaseSensitive;
                this.EnforceConstraints = dataSet.EnforceConstraints;
                this.Merge(dataSet, false, MissingSchemaAction.Add);
                this.InitVars();
            }
            else
            {
                this.ReadXml(reader);
                this.InitVars();
            }
        }

        [DebuggerNonUserCode]
        protected override bool ShouldSerializeRelations()
        {
            return false;
        }

        [DebuggerNonUserCode]
        protected override bool ShouldSerializeTables()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.DataSetName = "DatenschemaBMW";
            this.Prefix = "";
            this.Namespace = "http://tempuri.org/DatenschemaBMW.xsd";
            this.EnforceConstraints = true;
            this.SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
            this.tableTAB_F1_Header = new TAB_F1_HeaderDataTable();
            base.Tables.Add(this.tableTAB_F1_Header);
            this.tableTAB_F1_Detail = new TAB_F1_DetailDataTable();
            base.Tables.Add(this.tableTAB_F1_Detail);
            this.tableTAB_BMW_Bank_Header = new TAB_BMW_Bank_HeaderDataTable();
            base.Tables.Add(this.tableTAB_BMW_Bank_Header);
            this.tableTAB_BMW_Bank_Details = new TAB_BMW_Bank_DetailsDataTable();
            base.Tables.Add(this.tableTAB_BMW_Bank_Details);
            this.tableTAB_Auswertung = new TAB_AuswertungDataTable();
            base.Tables.Add(this.tableTAB_Auswertung);
            this.tableTAB_FinanzArten = new TAB_FinanzArtenDataTable();
            base.Tables.Add(this.tableTAB_FinanzArten);
            this.tableTAB_AuswertungTitle = new TAB_AuswertungTitleDataTable();
            base.Tables.Add(this.tableTAB_AuswertungTitle);
            this.tableTAB_Bestand_Header = new TAB_Bestand_HeaderDataTable();
            base.Tables.Add(this.tableTAB_Bestand_Header);
            this.tableTAB_Bestand_Details = new TAB_Bestand_DetailsDataTable();
            base.Tables.Add(this.tableTAB_Bestand_Details);
            this.tableTAB_Auswertung_Bestand = new TAB_Auswertung_BestandDataTable();
            base.Tables.Add(this.tableTAB_Auswertung_Bestand);
            this.tableTAB_Bemerkungen = new TAB_BemerkungenDataTable();
            base.Tables.Add(this.tableTAB_Bemerkungen);
            this.tableTAB_DauerFAs = new TAB_DauerFAsDataTable();
            base.Tables.Add(this.tableTAB_DauerFAs);
            this.tableTAB_Historie = new TAB_HistorieDataTable();
            base.Tables.Add(this.tableTAB_Historie);
            this.tableTAB_BMW_Debitorenkonten = new TAB_BMW_DebitorenkontenDataTable();
            base.Tables.Add(this.tableTAB_BMW_Debitorenkonten);
            this.tableTAB_BMW_Bank_Details_Alle_TMP = new TAB_BMW_Bank_Details_Alle_TMPDataTable();
            base.Tables.Add(this.tableTAB_BMW_Bank_Details_Alle_TMP);
            var constraint = new ForeignKeyConstraint(
                "FK_TAB_F1_Header_TAB_F1_Detail",
                new[] { this.tableTAB_F1_Header.F1_Header_IDColumn },
                new[] { this.tableTAB_F1_Detail.F1_Header_IDColumn });
            this.tableTAB_F1_Detail.Constraints.Add(constraint);
            constraint.AcceptRejectRule = AcceptRejectRule.None;
            constraint.DeleteRule = Rule.Cascade;
            constraint.UpdateRule = Rule.Cascade;
            constraint = new ForeignKeyConstraint(
                "TAB_BMW_Header_TAB_BMW_Detail",
                new[] { this.tableTAB_BMW_Bank_Header.BMW_Header_IDColumn },
                new[] { this.tableTAB_BMW_Bank_Details.BMW_Header_IDColumn });
            this.tableTAB_BMW_Bank_Details.Constraints.Add(constraint);
            constraint.AcceptRejectRule = AcceptRejectRule.None;
            constraint.DeleteRule = Rule.Cascade;
            constraint.UpdateRule = Rule.Cascade;
            constraint = new ForeignKeyConstraint(
                "TAB_Bestand_Header_TAB_Bestand_Details",
                new[] { this.tableTAB_Bestand_Header.Bestand_Header_IDColumn },
                new[] { this.tableTAB_Bestand_Details.Bestand_Header_IDColumn });
            this.tableTAB_Bestand_Details.Constraints.Add(constraint);
            constraint.AcceptRejectRule = AcceptRejectRule.None;
            constraint.DeleteRule = Rule.None;
            constraint.UpdateRule = Rule.None;
            this.relationFK_TAB_F1_Header_TAB_F1_Detail = new DataRelation(
                "FK_TAB_F1_Header_TAB_F1_Detail",
                new[] { this.tableTAB_F1_Header.F1_Header_IDColumn },
                new[] { this.tableTAB_F1_Detail.F1_Header_IDColumn },
                false);
            this.Relations.Add(this.relationFK_TAB_F1_Header_TAB_F1_Detail);
            this.relationTAB_BMW_Header_TAB_BMW_Detail = new DataRelation(
                "TAB_BMW_Header_TAB_BMW_Detail",
                new[] { this.tableTAB_BMW_Bank_Header.BMW_Header_IDColumn },
                new[] { this.tableTAB_BMW_Bank_Details.BMW_Header_IDColumn },
                false);
            this.Relations.Add(this.relationTAB_BMW_Header_TAB_BMW_Detail);
            this.relationTAB_Bestand_Header_TAB_Bestand_Details =
                new DataRelation(
                    "TAB_Bestand_Header_TAB_Bestand_Details",
                    new[] { this.tableTAB_Bestand_Header.Bestand_Header_IDColumn },
                    new[] { this.tableTAB_Bestand_Details.Bestand_Header_IDColumn },
                    false);
            this.Relations.Add(this.relationTAB_Bestand_Header_TAB_Bestand_Details);
        }

        [DebuggerNonUserCode]
        private void SchemaChanged(object sender, CollectionChangeEventArgs e)
        {
            if (e.Action == CollectionChangeAction.Remove)
            {
                this.InitVars();
            }
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_Auswertung()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_AuswertungTitle()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_Auswertung_Bestand()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_BMW_Bank_Details()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_BMW_Bank_Details_Alle_TMP()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_BMW_Bank_Header()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_BMW_Debitorenkonten()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_Bemerkungen()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_Bestand_Details()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_Bestand_Header()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_DauerFAs()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_F1_Detail()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_F1_Header()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_FinanzArten()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeTAB_Historie()
        {
            return false;
        }

        #endregion

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_AuswertungDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnAbgeloest;

            private DataColumn columnAusw_ID;

            private DataColumn columnBMW_Header_ID;

            private DataColumn columnBemerkung;

            private DataColumn columnF1_Header_ID;

            private DataColumn columnFA_ID;

            private DataColumn columnFGST_Nr;

            private DataColumn columnKredit_Nr;

            private DataColumn columnKredit_Saldo;

            private DataColumn columnKunden_Nr;

            private DataColumn columnName1;

            private DataColumn columnRE_Dat_VK;

            private DataColumn columnRE_Nr_Vk;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_AuswertungDataTable()
            {
                this.TableName = "TAB_Auswertung";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_AuswertungDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_AuswertungDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn AbgeloestColumn
            {
                get
                {
                    return this.columnAbgeloest;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Ausw_IDColumn
            {
                get
                {
                    return this.columnAusw_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn BMW_Header_IDColumn
            {
                get
                {
                    return this.columnBMW_Header_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn BemerkungColumn
            {
                get
                {
                    return this.columnBemerkung;
                }
            }

            [DebuggerNonUserCode]
            [Browsable(false)]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn F1_Header_IDColumn
            {
                get
                {
                    return this.columnF1_Header_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_IDColumn
            {
                get
                {
                    return this.columnFA_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_NrColumn
            {
                get
                {
                    return this.columnKredit_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_SaldoColumn
            {
                get
                {
                    return this.columnKredit_Saldo;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kunden_NrColumn
            {
                get
                {
                    return this.columnKunden_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Name1Column
            {
                get
                {
                    return this.columnName1;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn RE_Dat_VKColumn
            {
                get
                {
                    return this.columnRE_Dat_VK;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn RE_Nr_VkColumn
            {
                get
                {
                    return this.columnRE_Nr_Vk;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_AuswertungRow this[int index]
            {
                get
                {
                    return (TAB_AuswertungRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_AuswertungDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_AuswertungRow(TAB_AuswertungRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_AuswertungRow AddTAB_AuswertungRow(
                string FGST_Nr,
                string Name1,
                DateTime RE_Dat_VK,
                string RE_Nr_Vk,
                string Kunden_Nr,
                long FA_ID,
                string Kredit_Nr,
                double Kredit_Saldo,
                ulong F1_Header_ID,
                ulong BMW_Header_ID,
                string Bemerkung,
                bool Abgeloest)
            {
                var row = (TAB_AuswertungRow)this.NewRow();
                row.ItemArray = new object[]
                    {
                        null, FGST_Nr, Name1, RE_Dat_VK, RE_Nr_Vk, Kunden_Nr, FA_ID, Kredit_Nr, Kredit_Saldo, F1_Header_ID
                        , BMW_Header_ID, Bemerkung, Abgeloest
                    };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_AuswertungDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_AuswertungRow NewTAB_AuswertungRow()
            {
                return (TAB_AuswertungRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_AuswertungRow(TAB_AuswertungRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnAusw_ID = base.Columns["Ausw_ID"];
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnName1 = base.Columns["Name1"];
                this.columnRE_Dat_VK = base.Columns["RE_Dat_VK"];
                this.columnRE_Nr_Vk = base.Columns["RE_Nr_Vk"];
                this.columnKunden_Nr = base.Columns["Kunden_Nr"];
                this.columnFA_ID = base.Columns["FA_ID"];
                this.columnKredit_Nr = base.Columns["Kredit_Nr"];
                this.columnKredit_Saldo = base.Columns["Kredit_Saldo"];
                this.columnF1_Header_ID = base.Columns["F1_Header_ID"];
                this.columnBMW_Header_ID = base.Columns["BMW_Header_ID"];
                this.columnBemerkung = base.Columns["Bemerkung"];
                this.columnAbgeloest = base.Columns["Abgeloest"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_AuswertungDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_AuswertungRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_AuswertungRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_AuswertungRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungRowChangeEventHandler handler = this.TAB_AuswertungRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungRowChangeEvent((DatenschemaBMW.TAB_AuswertungRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_AuswertungRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungRowChangeEventHandler handler = this.TAB_AuswertungRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungRowChangeEvent((DatenschemaBMW.TAB_AuswertungRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_AuswertungRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungRowChangeEventHandler handler = this.TAB_AuswertungRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungRowChangeEvent((DatenschemaBMW.TAB_AuswertungRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_AuswertungRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungRowChangeEventHandler handler = this.TAB_AuswertungRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungRowChangeEvent((DatenschemaBMW.TAB_AuswertungRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnAusw_ID = new DataColumn("Ausw_ID", typeof(int), null, MappingType.Element);
                base.Columns.Add(this.columnAusw_ID);
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnName1 = new DataColumn("Name1", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName1);
                this.columnRE_Dat_VK = new DataColumn("RE_Dat_VK", typeof(DateTime), null, MappingType.Element);
                base.Columns.Add(this.columnRE_Dat_VK);
                this.columnRE_Nr_Vk = new DataColumn("RE_Nr_Vk", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnRE_Nr_Vk);
                this.columnKunden_Nr = new DataColumn("Kunden_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKunden_Nr);
                this.columnFA_ID = new DataColumn("FA_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnFA_ID);
                this.columnKredit_Nr = new DataColumn("Kredit_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Nr);
                this.columnKredit_Saldo = new DataColumn("Kredit_Saldo", typeof(double), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Saldo);
                this.columnF1_Header_ID = new DataColumn("F1_Header_ID", typeof(ulong), null, MappingType.Element);
                base.Columns.Add(this.columnF1_Header_ID);
                this.columnBMW_Header_ID = new DataColumn("BMW_Header_ID", typeof(ulong), null, MappingType.Element);
                base.Columns.Add(this.columnBMW_Header_ID);
                this.columnBemerkung = new DataColumn("Bemerkung", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBemerkung);
                this.columnAbgeloest = new DataColumn("Abgeloest", typeof(bool), null, MappingType.Element);
                base.Columns.Add(this.columnAbgeloest);
                this.Constraints.Add(new UniqueConstraint("Constraint2", new[] { this.columnAusw_ID }, false));
                this.columnAusw_ID.AutoIncrement = true;
                this.columnAusw_ID.AutoIncrementSeed = 1L;
                this.columnAusw_ID.Unique = true;
                this.columnFGST_Nr.MaxLength = 40;
                this.columnName1.MaxLength = 100;
                this.columnRE_Nr_Vk.MaxLength = 30;
                this.columnKunden_Nr.MaxLength = 20;
                this.columnFA_ID.DefaultValue = 0L;
                this.columnKredit_Nr.MaxLength = 50;
                this.columnAbgeloest.DefaultValue = false;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_AuswertungRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_AuswertungDataTable tableTAB_Auswertung;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_AuswertungRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_Auswertung = (TAB_AuswertungDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public bool Abgeloest
            {
                get
                {
                    bool flag;
                    try
                    {
                        flag = Conversions.ToBoolean(this[this.tableTAB_Auswertung.AbgeloestColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Abgeloest in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return flag;
                }
                set
                {
                    this[this.tableTAB_Auswertung.AbgeloestColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public int Ausw_ID
            {
                get
                {
                    int num;
                    try
                    {
                        num = Conversions.ToInteger(this[this.tableTAB_Auswertung.Ausw_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Ausw_ID in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung.Ausw_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public ulong BMW_Header_ID
            {
                get
                {
                    ulong num;
                    try
                    {
                        num = Conversions.ToULong(this[this.tableTAB_Auswertung.BMW_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte BMW_Header_ID in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung.BMW_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Bemerkung
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_Auswertung.BemerkungColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bemerkung in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_Auswertung.BemerkungColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public ulong F1_Header_ID
            {
                get
                {
                    ulong num;
                    try
                    {
                        num = Conversions.ToULong(this[this.tableTAB_Auswertung.F1_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte F1_Header_ID in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung.F1_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long FA_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_Auswertung.FA_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FA_ID in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung.FA_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    if (this.IsFGST_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Auswertung.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Auswertung.FGST_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kredit_Nr
            {
                get
                {
                    if (this.IsKredit_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Auswertung.Kredit_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Auswertung.Kredit_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public double Kredit_Saldo
            {
                get
                {
                    double num;
                    try
                    {
                        num = Conversions.ToDouble(this[this.tableTAB_Auswertung.Kredit_SaldoColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Kredit_Saldo in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung.Kredit_SaldoColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kunden_Nr
            {
                get
                {
                    if (this.IsKunden_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Auswertung.Kunden_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Auswertung.Kunden_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name1
            {
                get
                {
                    if (this.IsName1Null())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Auswertung.Name1Column]);
                }
                set
                {
                    this[this.tableTAB_Auswertung.Name1Column] = value;
                }
            }

            [DebuggerNonUserCode]
            public DateTime RE_Dat_VK
            {
                get
                {
                    DateTime time;
                    try
                    {
                        time = Conversions.ToDate(this[this.tableTAB_Auswertung.RE_Dat_VKColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte RE_Dat_VK in Tabelle TAB_Auswertung ist DBNull.", innerException);
                    }
                    return time;
                }
                set
                {
                    this[this.tableTAB_Auswertung.RE_Dat_VKColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string RE_Nr_Vk
            {
                get
                {
                    if (this.IsRE_Nr_VkNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Auswertung.RE_Nr_VkColumn]);
                }
                set
                {
                    this[this.tableTAB_Auswertung.RE_Nr_VkColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsAbgeloestNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.AbgeloestColumn);
            }

            [DebuggerNonUserCode]
            public bool IsAusw_IDNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.Ausw_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBMW_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.BMW_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBemerkungNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.BemerkungColumn);
            }

            [DebuggerNonUserCode]
            public bool IsF1_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.F1_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_IDNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.FA_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFGST_NrNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.FGST_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_NrNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.Kredit_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_SaldoNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.Kredit_SaldoColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKunden_NrNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.Kunden_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsName1Null()
            {
                return this.IsNull(this.tableTAB_Auswertung.Name1Column);
            }

            [DebuggerNonUserCode]
            public bool IsRE_Dat_VKNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.RE_Dat_VKColumn);
            }

            [DebuggerNonUserCode]
            public bool IsRE_Nr_VkNull()
            {
                return this.IsNull(this.tableTAB_Auswertung.RE_Nr_VkColumn);
            }

            [DebuggerNonUserCode]
            public void SetAbgeloestNull()
            {
                this[this.tableTAB_Auswertung.AbgeloestColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetAusw_IDNull()
            {
                this[this.tableTAB_Auswertung.Ausw_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBMW_Header_IDNull()
            {
                this[this.tableTAB_Auswertung.BMW_Header_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBemerkungNull()
            {
                this[this.tableTAB_Auswertung.BemerkungColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetF1_Header_IDNull()
            {
                this[this.tableTAB_Auswertung.F1_Header_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_IDNull()
            {
                this[this.tableTAB_Auswertung.FA_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFGST_NrNull()
            {
                this[this.tableTAB_Auswertung.FGST_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_NrNull()
            {
                this[this.tableTAB_Auswertung.Kredit_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_SaldoNull()
            {
                this[this.tableTAB_Auswertung.Kredit_SaldoColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKunden_NrNull()
            {
                this[this.tableTAB_Auswertung.Kunden_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetName1Null()
            {
                this[this.tableTAB_Auswertung.Name1Column] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetRE_Dat_VKNull()
            {
                this[this.tableTAB_Auswertung.RE_Dat_VKColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetRE_Nr_VkNull()
            {
                this[this.tableTAB_Auswertung.RE_Nr_VkColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_AuswertungRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_AuswertungRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_AuswertungRowChangeEvent(TAB_AuswertungRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_AuswertungRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_AuswertungTitleDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnDataBaseVersion;

            private DataColumn columnTitle;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_AuswertungTitleDataTable()
            {
                this.TableName = "TAB_AuswertungTitle";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_AuswertungTitleDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_AuswertungTitleDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

            #region Public Properties

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn DataBaseVersionColumn
            {
                get
                {
                    return this.columnDataBaseVersion;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn TitleColumn
            {
                get
                {
                    return this.columnTitle;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_AuswertungTitleRow this[int index]
            {
                get
                {
                    return (TAB_AuswertungTitleRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_AuswertungTitleDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_AuswertungTitleRow(TAB_AuswertungTitleRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_AuswertungTitleRow AddTAB_AuswertungTitleRow(string Title, int DataBaseVersion)
            {
                var row = (TAB_AuswertungTitleRow)this.NewRow();
                row.ItemArray = new object[] { Title, DataBaseVersion };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_AuswertungTitleDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_AuswertungTitleRow NewTAB_AuswertungTitleRow()
            {
                return (TAB_AuswertungTitleRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_AuswertungTitleRow(TAB_AuswertungTitleRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnTitle = base.Columns["Title"];
                this.columnDataBaseVersion = base.Columns["DataBaseVersion"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_AuswertungTitleDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_AuswertungTitleRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_AuswertungTitleRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_AuswertungTitleRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungTitleRowChangeEventHandler handler = this.TAB_AuswertungTitleRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungTitleRowChangeEvent((DatenschemaBMW.TAB_AuswertungTitleRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_AuswertungTitleRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungTitleRowChangeEventHandler handler = this.TAB_AuswertungTitleRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungTitleRowChangeEvent((DatenschemaBMW.TAB_AuswertungTitleRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_AuswertungTitleRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungTitleRowChangeEventHandler handler = this.TAB_AuswertungTitleRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungTitleRowChangeEvent((DatenschemaBMW.TAB_AuswertungTitleRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_AuswertungTitleRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_AuswertungTitleRowChangeEventHandler handler = this.TAB_AuswertungTitleRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_AuswertungTitleRowChangeEvent((DatenschemaBMW.TAB_AuswertungTitleRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnTitle = new DataColumn("Title", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnTitle);
                this.columnDataBaseVersion = new DataColumn("DataBaseVersion", typeof(int), null, MappingType.Element);
                base.Columns.Add(this.columnDataBaseVersion);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_AuswertungTitleRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_AuswertungTitleDataTable tableTAB_AuswertungTitle;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_AuswertungTitleRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_AuswertungTitle = (TAB_AuswertungTitleDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public int DataBaseVersion
            {
                get
                {
                    int num;
                    try
                    {
                        num = Conversions.ToInteger(this[this.tableTAB_AuswertungTitle.DataBaseVersionColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte DataBaseVersion in Tabelle TAB_AuswertungTitle ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_AuswertungTitle.DataBaseVersionColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Title
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_AuswertungTitle.TitleColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Title in Tabelle TAB_AuswertungTitle ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_AuswertungTitle.TitleColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsDataBaseVersionNull()
            {
                return this.IsNull(this.tableTAB_AuswertungTitle.DataBaseVersionColumn);
            }

            [DebuggerNonUserCode]
            public bool IsTitleNull()
            {
                return this.IsNull(this.tableTAB_AuswertungTitle.TitleColumn);
            }

            [DebuggerNonUserCode]
            public void SetDataBaseVersionNull()
            {
                this[this.tableTAB_AuswertungTitle.DataBaseVersionColumn] = RuntimeHelpers.GetObjectValue(
                    Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetTitleNull()
            {
                this[this.tableTAB_AuswertungTitle.TitleColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_AuswertungTitleRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_AuswertungTitleRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_AuswertungTitleRowChangeEvent(TAB_AuswertungTitleRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_AuswertungTitleRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Auswertung_BestandDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn _columnEK_Preis;

            private DataColumn columnAusw_Best_ID;

            private DataColumn columnBemerkung;

            private DataColumn columnBestand_Header_ID;

            private DataColumn columnDatum;

            private DataColumn columnFGST_Nr;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_Auswertung_BestandDataTable()
            {
                this.TableName = "TAB_Auswertung_Bestand";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_Auswertung_BestandDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_Auswertung_BestandDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn Ausw_Best_IDColumn
            {
                get
                {
                    return this.columnAusw_Best_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn BemerkungColumn
            {
                get
                {
                    return this.columnBemerkung;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Bestand_Header_IDColumn
            {
                get
                {
                    return this.columnBestand_Header_ID;
                }
            }

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn DatumColumn
            {
                get
                {
                    return this.columnDatum;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn _EK_PreisColumn
            {
                get
                {
                    return this._columnEK_Preis;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_Auswertung_BestandRow this[int index]
            {
                get
                {
                    return (TAB_Auswertung_BestandRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_Auswertung_BestandDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_Auswertung_BestandRow(TAB_Auswertung_BestandRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_Auswertung_BestandRow AddTAB_Auswertung_BestandRow(
                string FGST_Nr, DateTime Datum, double _EK_Preis, long Bestand_Header_ID, string Bemerkung)
            {
                var row = (TAB_Auswertung_BestandRow)this.NewRow();
                row.ItemArray = new object[] { null, FGST_Nr, Datum, _EK_Preis, Bestand_Header_ID, Bemerkung };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_Auswertung_BestandDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_Auswertung_BestandRow NewTAB_Auswertung_BestandRow()
            {
                return (TAB_Auswertung_BestandRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_Auswertung_BestandRow(TAB_Auswertung_BestandRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnAusw_Best_ID = base.Columns["Ausw_Best_ID"];
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnDatum = base.Columns["Datum"];
                this._columnEK_Preis = base.Columns["EK-Preis"];
                this.columnBestand_Header_ID = base.Columns["Bestand_Header_ID"];
                this.columnBemerkung = base.Columns["Bemerkung"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_Auswertung_BestandDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_Auswertung_BestandRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_Auswertung_BestandRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_Auswertung_BestandRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_Auswertung_BestandRowChangeEventHandler handler = this.TAB_Auswertung_BestandRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Auswertung_BestandRowChangeEvent((DatenschemaBMW.TAB_Auswertung_BestandRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_Auswertung_BestandRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_Auswertung_BestandRowChangeEventHandler handler = this.TAB_Auswertung_BestandRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Auswertung_BestandRowChangeEvent((DatenschemaBMW.TAB_Auswertung_BestandRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_Auswertung_BestandRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_Auswertung_BestandRowChangeEventHandler handler = this.TAB_Auswertung_BestandRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Auswertung_BestandRowChangeEvent((DatenschemaBMW.TAB_Auswertung_BestandRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_Auswertung_BestandRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_Auswertung_BestandRowChangeEventHandler handler = this.TAB_Auswertung_BestandRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Auswertung_BestandRowChangeEvent((DatenschemaBMW.TAB_Auswertung_BestandRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnAusw_Best_ID = new DataColumn("Ausw_Best_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnAusw_Best_ID);
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnDatum = new DataColumn("Datum", typeof(DateTime), null, MappingType.Element);
                base.Columns.Add(this.columnDatum);
                this._columnEK_Preis = new DataColumn("EK-Preis", typeof(double), null, MappingType.Element);
                this._columnEK_Preis.ExtendedProperties.Add("Generator_ColumnVarNameInTable", "_columnEK_Preis");
                this._columnEK_Preis.ExtendedProperties.Add("Generator_UserColumnName", "EK-Preis");
                base.Columns.Add(this._columnEK_Preis);
                this.columnBestand_Header_ID = new DataColumn(
                    "Bestand_Header_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnBestand_Header_ID);
                this.columnBemerkung = new DataColumn("Bemerkung", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBemerkung);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new[] { this.columnAusw_Best_ID }, false));
                this.columnAusw_Best_ID.AutoIncrement = true;
                this.columnAusw_Best_ID.AutoIncrementSeed = 1L;
                this.columnAusw_Best_ID.Unique = true;
                this.columnFGST_Nr.MaxLength = 40;
                this.columnBemerkung.DefaultValue = "";
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Auswertung_BestandRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_Auswertung_BestandDataTable tableTAB_Auswertung_Bestand;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_Auswertung_BestandRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_Auswertung_Bestand = (TAB_Auswertung_BestandDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public long Ausw_Best_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_Auswertung_Bestand.Ausw_Best_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Ausw_Best_ID in Tabelle TAB_Auswertung_Bestand ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung_Bestand.Ausw_Best_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Bemerkung
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_Auswertung_Bestand.BemerkungColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bemerkung in Tabelle TAB_Auswertung_Bestand ist DBNull.",
                            innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_Auswertung_Bestand.BemerkungColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long Bestand_Header_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_Auswertung_Bestand.Bestand_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bestand_Header_ID in Tabelle TAB_Auswertung_Bestand ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung_Bestand.Bestand_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public DateTime Datum
            {
                get
                {
                    DateTime time;
                    try
                    {
                        time = Conversions.ToDate(this[this.tableTAB_Auswertung_Bestand.DatumColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Datum in Tabelle TAB_Auswertung_Bestand ist DBNull.", innerException);
                    }
                    return time;
                }
                set
                {
                    this[this.tableTAB_Auswertung_Bestand.DatumColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_Auswertung_Bestand.FGST_NrColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FGST_Nr in Tabelle TAB_Auswertung_Bestand ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_Auswertung_Bestand.FGST_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public double _EK_Preis
            {
                get
                {
                    double num;
                    try
                    {
                        num = Conversions.ToDouble(this[this.tableTAB_Auswertung_Bestand._EK_PreisColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte EK-Preis in Tabelle TAB_Auswertung_Bestand ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Auswertung_Bestand._EK_PreisColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsAusw_Best_IDNull()
            {
                return this.IsNull(this.tableTAB_Auswertung_Bestand.Ausw_Best_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBemerkungNull()
            {
                return this.IsNull(this.tableTAB_Auswertung_Bestand.BemerkungColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBestand_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_Auswertung_Bestand.Bestand_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsDatumNull()
            {
                return this.IsNull(this.tableTAB_Auswertung_Bestand.DatumColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFGST_NrNull()
            {
                return this.IsNull(this.tableTAB_Auswertung_Bestand.FGST_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool Is_EK_PreisNull()
            {
                return this.IsNull(this.tableTAB_Auswertung_Bestand._EK_PreisColumn);
            }

            [DebuggerNonUserCode]
            public void SetAusw_Best_IDNull()
            {
                this[this.tableTAB_Auswertung_Bestand.Ausw_Best_IDColumn] = RuntimeHelpers.GetObjectValue(
                    Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBemerkungNull()
            {
                this[this.tableTAB_Auswertung_Bestand.BemerkungColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBestand_Header_IDNull()
            {
                this[this.tableTAB_Auswertung_Bestand.Bestand_Header_IDColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetDatumNull()
            {
                this[this.tableTAB_Auswertung_Bestand.DatumColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFGST_NrNull()
            {
                this[this.tableTAB_Auswertung_Bestand.FGST_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void Set_EK_PreisNull()
            {
                this[this.tableTAB_Auswertung_Bestand._EK_PreisColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Auswertung_BestandRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_Auswertung_BestandRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_Auswertung_BestandRowChangeEvent(TAB_Auswertung_BestandRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_Auswertung_BestandRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_DetailsDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnBMW_Detail_ID;

            private DataColumn columnBMW_Header_ID;

            private DataColumn columnBemerkung;

            private DataColumn columnFA_Art;

            private DataColumn columnFGST_Nr;

            private DataColumn columnFZG_Typ;

            private DataColumn columnKredit_Beginn;

            private DataColumn columnKredit_Nr;

            private DataColumn columnKredit_Saldo;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsDataTable()
            {
                this.TableName = "TAB_BMW_Bank_Details";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_BMW_Bank_DetailsDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_BMW_Bank_DetailsDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

          

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn BMW_Detail_IDColumn
            {
                get
                {
                    return this.columnBMW_Detail_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn BMW_Header_IDColumn
            {
                get
                {
                    return this.columnBMW_Header_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn BemerkungColumn
            {
                get
                {
                    return this.columnBemerkung;
                }
            }

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_ArtColumn
            {
                get
                {
                    return this.columnFA_Art;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FZG_TypColumn
            {
                get
                {
                    return this.columnFZG_Typ;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_BeginnColumn
            {
                get
                {
                    return this.columnKredit_Beginn;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_NrColumn
            {
                get
                {
                    return this.columnKredit_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_SaldoColumn
            {
                get
                {
                    return this.columnKredit_Saldo;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsRow this[int index]
            {
                get
                {
                    return (TAB_BMW_Bank_DetailsRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_BMW_Bank_DetailsDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_BMW_Bank_DetailsRow(TAB_BMW_Bank_DetailsRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsRow AddTAB_BMW_Bank_DetailsRow(
                TAB_BMW_Bank_HeaderRow parentTAB_BMW_Bank_HeaderRowByTAB_BMW_Header_TAB_BMW_Detail,
                string Kredit_Nr,
                string FGST_Nr,
                DateTime Kredit_Beginn,
                string FA_Art,
                string FZG_Typ,
                double Kredit_Saldo,
                string Bemerkung)
            {
                var row = (TAB_BMW_Bank_DetailsRow)this.NewRow();
                var objArray = new object[]
                    { null, null, Kredit_Nr, FGST_Nr, Kredit_Beginn, FA_Art, FZG_Typ, Kredit_Saldo, Bemerkung };
                if (parentTAB_BMW_Bank_HeaderRowByTAB_BMW_Header_TAB_BMW_Detail != null)
                {
                    objArray[1] =
                        RuntimeHelpers.GetObjectValue(parentTAB_BMW_Bank_HeaderRowByTAB_BMW_Header_TAB_BMW_Detail[0]);
                }
                row.ItemArray = objArray;
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_BMW_Bank_DetailsDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsRow FindByBMW_Detail_ID(long BMW_Detail_ID)
            {
                return (TAB_BMW_Bank_DetailsRow)this.Rows.Find(new object[] { BMW_Detail_ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsRow NewTAB_BMW_Bank_DetailsRow()
            {
                return (TAB_BMW_Bank_DetailsRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_BMW_Bank_DetailsRow(TAB_BMW_Bank_DetailsRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnBMW_Detail_ID = base.Columns["BMW_Detail_ID"];
                this.columnBMW_Header_ID = base.Columns["BMW_Header_ID"];
                this.columnKredit_Nr = base.Columns["Kredit_Nr"];
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnKredit_Beginn = base.Columns["Kredit_Beginn"];
                this.columnFA_Art = base.Columns["FA_Art"];
                this.columnFZG_Typ = base.Columns["FZG_Typ"];
                this.columnKredit_Saldo = base.Columns["Kredit_Saldo"];
                this.columnBemerkung = base.Columns["Bemerkung"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_BMW_Bank_DetailsDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_BMW_Bank_DetailsRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_BMW_Bank_DetailsRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_BMW_Bank_DetailsRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEventHandler handler = this.TAB_BMW_Bank_DetailsRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_BMW_Bank_DetailsRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEventHandler handler = this.TAB_BMW_Bank_DetailsRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_BMW_Bank_DetailsRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEventHandler handler = this.TAB_BMW_Bank_DetailsRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_BMW_Bank_DetailsRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEventHandler handler = this.TAB_BMW_Bank_DetailsRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_DetailsRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnBMW_Detail_ID = new DataColumn("BMW_Detail_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnBMW_Detail_ID);
                this.columnBMW_Header_ID = new DataColumn("BMW_Header_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnBMW_Header_ID);
                this.columnKredit_Nr = new DataColumn("Kredit_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Nr);
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnKredit_Beginn = new DataColumn("Kredit_Beginn", typeof(DateTime), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Beginn);
                this.columnFA_Art = new DataColumn("FA_Art", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFA_Art);
                this.columnFZG_Typ = new DataColumn("FZG_Typ", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFZG_Typ);
                this.columnKredit_Saldo = new DataColumn("Kredit_Saldo", typeof(double), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Saldo);
                this.columnBemerkung = new DataColumn("Bemerkung", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBemerkung);
                this.Constraints.Add(
                    new UniqueConstraint("TAB_BMW_Bank_DetailsKey1", new[] { this.columnBMW_Detail_ID }, true));
                this.columnBMW_Detail_ID.AutoIncrement = true;
                this.columnBMW_Detail_ID.AutoIncrementSeed = 1L;
                this.columnBMW_Detail_ID.AllowDBNull = false;
                this.columnBMW_Detail_ID.Unique = true;
                this.columnKredit_Nr.MaxLength = 50;
                this.columnFGST_Nr.MaxLength = 40;
                this.columnFA_Art.MaxLength = 100;
                this.columnFZG_Typ.MaxLength = 100;
                this.columnBemerkung.DefaultValue = "";
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_DetailsRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_BMW_Bank_DetailsDataTable tableTAB_BMW_Bank_Details;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_BMW_Bank_DetailsRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_BMW_Bank_Details = (TAB_BMW_Bank_DetailsDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public long BMW_Detail_ID
            {
                get
                {
                    return Conversions.ToLong(this[this.tableTAB_BMW_Bank_Details.BMW_Detail_IDColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.BMW_Detail_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long BMW_Header_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_BMW_Bank_Details.BMW_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte BMW_Header_ID in Tabelle TAB_BMW_Bank_Details ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.BMW_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Bemerkung
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_BMW_Bank_Details.BemerkungColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bemerkung in Tabelle TAB_BMW_Bank_Details ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.BemerkungColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FA_Art
            {
                get
                {
                    if (this.IsFA_ArtNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details.FA_ArtColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.FA_ArtColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    if (this.IsFGST_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.FGST_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FZG_Typ
            {
                get
                {
                    if (this.IsFZG_TypNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details.FZG_TypColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.FZG_TypColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public DateTime Kredit_Beginn
            {
                get
                {
                    DateTime time;
                    try
                    {
                        time = Conversions.ToDate(this[this.tableTAB_BMW_Bank_Details.Kredit_BeginnColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Kredit_Beginn in Tabelle TAB_BMW_Bank_Details ist DBNull.",
                            innerException);
                    }
                    return time;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.Kredit_BeginnColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kredit_Nr
            {
                get
                {
                    if (this.IsKredit_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details.Kredit_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.Kredit_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public double Kredit_Saldo
            {
                get
                {
                    double num;
                    try
                    {
                        num = Conversions.ToDouble(this[this.tableTAB_BMW_Bank_Details.Kredit_SaldoColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Kredit_Saldo in Tabelle TAB_BMW_Bank_Details ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details.Kredit_SaldoColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderRow TAB_BMW_Bank_HeaderRow
            {
                get
                {
                    return
                        (TAB_BMW_Bank_HeaderRow)
                        this.GetParentRow(this.Table.ParentRelations["TAB_BMW_Header_TAB_BMW_Detail"]);
                }
                set
                {
                    this.SetParentRow(value, this.Table.ParentRelations["TAB_BMW_Header_TAB_BMW_Detail"]);
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsBMW_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.BMW_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBemerkungNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.BemerkungColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_ArtNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.FA_ArtColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFGST_NrNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.FGST_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFZG_TypNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.FZG_TypColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_BeginnNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.Kredit_BeginnColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_NrNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.Kredit_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_SaldoNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details.Kredit_SaldoColumn);
            }

            [DebuggerNonUserCode]
            public void SetBMW_Header_IDNull()
            {
                this[this.tableTAB_BMW_Bank_Details.BMW_Header_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBemerkungNull()
            {
                this[this.tableTAB_BMW_Bank_Details.BemerkungColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_ArtNull()
            {
                this[this.tableTAB_BMW_Bank_Details.FA_ArtColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFGST_NrNull()
            {
                this[this.tableTAB_BMW_Bank_Details.FGST_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFZG_TypNull()
            {
                this[this.tableTAB_BMW_Bank_Details.FZG_TypColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_BeginnNull()
            {
                this[this.tableTAB_BMW_Bank_Details.Kredit_BeginnColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_NrNull()
            {
                this[this.tableTAB_BMW_Bank_Details.Kredit_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_SaldoNull()
            {
                this[this.tableTAB_BMW_Bank_Details.Kredit_SaldoColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_DetailsRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_BMW_Bank_DetailsRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsRowChangeEvent(TAB_BMW_Bank_DetailsRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        [XmlSchemaProvider("GetTypedTableSchema")]
        public class TAB_BMW_Bank_Details_Alle_TMPDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnDeb_Kto_No;

            private DataColumn columnFA_Art;

            private DataColumn columnFGST_Nr;

            private DataColumn columnFZG_Typ;

            private DataColumn columnKredit_Beginn;

            private DataColumn columnKredit_Nr;

            private DataColumn columnKredit_Saldo;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_Details_Alle_TMPDataTable()
            {
                this.TableName = "TAB_BMW_Bank_Details_Alle_TMP";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_BMW_Bank_Details_Alle_TMPDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_BMW_Bank_Details_Alle_TMPDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

           

            #region Public Properties

            [DebuggerNonUserCode]
            [Browsable(false)]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Deb_Kto_NoColumn
            {
                get
                {
                    return this.columnDeb_Kto_No;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_ArtColumn
            {
                get
                {
                    return this.columnFA_Art;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FZG_TypColumn
            {
                get
                {
                    return this.columnFZG_Typ;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_BeginnColumn
            {
                get
                {
                    return this.columnKredit_Beginn;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_NrColumn
            {
                get
                {
                    return this.columnKredit_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_SaldoColumn
            {
                get
                {
                    return this.columnKredit_Saldo;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_Details_Alle_TMPRow this[int index]
            {
                get
                {
                    return (TAB_BMW_Bank_Details_Alle_TMPRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_BMW_Bank_Details_Alle_TMPDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_BMW_Bank_Details_Alle_TMPRow(TAB_BMW_Bank_Details_Alle_TMPRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_Details_Alle_TMPRow AddTAB_BMW_Bank_Details_Alle_TMPRow(
                string Kredit_Nr,
                string FGST_Nr,
                DateTime Kredit_Beginn,
                string FA_Art,
                string FZG_Typ,
                double Kredit_Saldo,
                string Deb_Kto_No)
            {
                var row = (TAB_BMW_Bank_Details_Alle_TMPRow)this.NewRow();
                row.ItemArray = new object[]
                    { Kredit_Nr, FGST_Nr, Kredit_Beginn, FA_Art, FZG_Typ, Kredit_Saldo, Deb_Kto_No };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_BMW_Bank_Details_Alle_TMPDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_Details_Alle_TMPRow NewTAB_BMW_Bank_Details_Alle_TMPRow()
            {
                return (TAB_BMW_Bank_Details_Alle_TMPRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_BMW_Bank_Details_Alle_TMPRow(TAB_BMW_Bank_Details_Alle_TMPRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnKredit_Nr = base.Columns["Kredit_Nr"];
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnKredit_Beginn = base.Columns["Kredit_Beginn"];
                this.columnFA_Art = base.Columns["FA_Art"];
                this.columnFZG_Typ = base.Columns["FZG_Typ"];
                this.columnKredit_Saldo = base.Columns["Kredit_Saldo"];
                this.columnDeb_Kto_No = base.Columns["Deb_Kto_No"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_BMW_Bank_Details_Alle_TMPDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_BMW_Bank_Details_Alle_TMPRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_BMW_Bank_Details_Alle_TMPRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_BMW_Bank_Details_Alle_TMPRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEventHandler handler = this.TAB_BMW_Bank_Details_Alle_TMPRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_BMW_Bank_Details_Alle_TMPRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEventHandler handler = this.TAB_BMW_Bank_Details_Alle_TMPRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_BMW_Bank_Details_Alle_TMPRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEventHandler handler = this.TAB_BMW_Bank_Details_Alle_TMPRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_BMW_Bank_Details_Alle_TMPRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEventHandler handler = this.TAB_BMW_Bank_Details_Alle_TMPRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_Details_Alle_TMPRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnKredit_Nr = new DataColumn("Kredit_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Nr);
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnKredit_Beginn = new DataColumn("Kredit_Beginn", typeof(DateTime), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Beginn);
                this.columnFA_Art = new DataColumn("FA_Art", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFA_Art);
                this.columnFZG_Typ = new DataColumn("FZG_Typ", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFZG_Typ);
                this.columnKredit_Saldo = new DataColumn("Kredit_Saldo", typeof(double), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Saldo);
                this.columnDeb_Kto_No = new DataColumn("Deb_Kto_No", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnDeb_Kto_No);
                this.columnKredit_Nr.MaxLength = 50;
                this.columnFGST_Nr.MaxLength = 40;
                this.columnFA_Art.MaxLength = 100;
                this.columnFZG_Typ.MaxLength = 100;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_Details_Alle_TMPRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_BMW_Bank_Details_Alle_TMPDataTable tableTAB_BMW_Bank_Details_Alle_TMP;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_BMW_Bank_Details_Alle_TMPRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_BMW_Bank_Details_Alle_TMP = (TAB_BMW_Bank_Details_Alle_TMPDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public string Deb_Kto_No
            {
                get
                {
                    if (this.IsDeb_Kto_NoNull())
                    {
                        return null;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Deb_Kto_NoColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Deb_Kto_NoColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FA_Art
            {
                get
                {
                    if (this.IsFA_ArtNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FA_ArtColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FA_ArtColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    if (this.IsFGST_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FGST_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FZG_Typ
            {
                get
                {
                    if (this.IsFZG_TypNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FZG_TypColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FZG_TypColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public DateTime Kredit_Beginn
            {
                get
                {
                    DateTime time;
                    try
                    {
                        time = Conversions.ToDate(this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_BeginnColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Kredit_Beginn in Tabelle TAB_BMW_Bank_Details_Alle_TMP ist DBNull.",
                            innerException);
                    }
                    return time;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_BeginnColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kredit_Nr
            {
                get
                {
                    if (this.IsKredit_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public double Kredit_Saldo
            {
                get
                {
                    double num;
                    try
                    {
                        num = Conversions.ToDouble(this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_SaldoColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Kredit_Saldo in Tabelle TAB_BMW_Bank_Details_Alle_TMP ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_SaldoColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsDeb_Kto_NoNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details_Alle_TMP.Deb_Kto_NoColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_ArtNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details_Alle_TMP.FA_ArtColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFGST_NrNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details_Alle_TMP.FGST_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFZG_TypNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details_Alle_TMP.FZG_TypColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_BeginnNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_BeginnColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_NrNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_SaldoNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_SaldoColumn);
            }

            [DebuggerNonUserCode]
            public void SetDeb_Kto_NoNull()
            {
                this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Deb_Kto_NoColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_ArtNull()
            {
                this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FA_ArtColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFGST_NrNull()
            {
                this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FGST_NrColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFZG_TypNull()
            {
                this[this.tableTAB_BMW_Bank_Details_Alle_TMP.FZG_TypColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_BeginnNull()
            {
                this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_BeginnColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_NrNull()
            {
                this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_NrColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_SaldoNull()
            {
                this[this.tableTAB_BMW_Bank_Details_Alle_TMP.Kredit_SaldoColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_Details_Alle_TMPRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_BMW_Bank_Details_Alle_TMPRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_Details_Alle_TMPRowChangeEvent(
                TAB_BMW_Bank_Details_Alle_TMPRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_Details_Alle_TMPRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_HeaderDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnBMW_Header_ID;

            private DataColumn columnDeb_Kto_Nr;

            private DataColumn columnFileName;

            private DataColumn columnLastChanged;

            private DataColumn columnName;

            private DataColumn columnOrt;

            private DataColumn columnTyp;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderDataTable()
            {
                this.TableName = "TAB_BMW_Bank_Header";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_BMW_Bank_HeaderDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_BMW_Bank_HeaderDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

        

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn BMW_Header_IDColumn
            {
                get
                {
                    return this.columnBMW_Header_ID;
                }
            }

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Deb_Kto_NrColumn
            {
                get
                {
                    return this.columnDeb_Kto_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FileNameColumn
            {
                get
                {
                    return this.columnFileName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn LastChangedColumn
            {
                get
                {
                    return this.columnLastChanged;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn OrtColumn
            {
                get
                {
                    return this.columnOrt;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn TypColumn
            {
                get
                {
                    return this.columnTyp;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderRow this[int index]
            {
                get
                {
                    return (TAB_BMW_Bank_HeaderRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_BMW_Bank_HeaderDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_BMW_Bank_HeaderRow(TAB_BMW_Bank_HeaderRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderRow AddTAB_BMW_Bank_HeaderRow(
                string FileName, string Deb_Kto_Nr, string Name, string Ort, string Typ, string LastChanged)
            {
                var row = (TAB_BMW_Bank_HeaderRow)this.NewRow();
                row.ItemArray = new object[] { null, FileName, Deb_Kto_Nr, Name, Ort, Typ, LastChanged };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_BMW_Bank_HeaderDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderRow FindByBMW_Header_ID(long BMW_Header_ID)
            {
                return (TAB_BMW_Bank_HeaderRow)this.Rows.Find(new object[] { BMW_Header_ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderRow NewTAB_BMW_Bank_HeaderRow()
            {
                return (TAB_BMW_Bank_HeaderRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_BMW_Bank_HeaderRow(TAB_BMW_Bank_HeaderRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnBMW_Header_ID = base.Columns["BMW_Header_ID"];
                this.columnFileName = base.Columns["FileName"];
                this.columnDeb_Kto_Nr = base.Columns["Deb_Kto_Nr"];
                this.columnName = base.Columns["Name"];
                this.columnOrt = base.Columns["Ort"];
                this.columnTyp = base.Columns["Typ"];
                this.columnLastChanged = base.Columns["LastChanged"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_BMW_Bank_HeaderDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_BMW_Bank_HeaderRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_BMW_Bank_HeaderRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_BMW_Bank_HeaderRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEventHandler handler = this.TAB_BMW_Bank_HeaderRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_BMW_Bank_HeaderRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEventHandler handler = this.TAB_BMW_Bank_HeaderRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_BMW_Bank_HeaderRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEventHandler handler = this.TAB_BMW_Bank_HeaderRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_BMW_Bank_HeaderRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEventHandler handler = this.TAB_BMW_Bank_HeaderRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_Bank_HeaderRowChangeEvent((DatenschemaBMW.TAB_BMW_Bank_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnBMW_Header_ID = new DataColumn("BMW_Header_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnBMW_Header_ID);
                this.columnFileName = new DataColumn("FileName", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFileName);
                this.columnDeb_Kto_Nr = new DataColumn("Deb_Kto_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnDeb_Kto_Nr);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                this.columnOrt = new DataColumn("Ort", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnOrt);
                this.columnTyp = new DataColumn("Typ", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnTyp);
                this.columnLastChanged = new DataColumn("LastChanged", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnLastChanged);
                this.Constraints.Add(
                    new UniqueConstraint("TAB_BMW_Bank_HeaderKey1", new[] { this.columnBMW_Header_ID }, true));
                this.columnBMW_Header_ID.AutoIncrement = true;
                this.columnBMW_Header_ID.AutoIncrementSeed = 1L;
                this.columnBMW_Header_ID.AllowDBNull = false;
                this.columnBMW_Header_ID.Unique = true;
                this.columnDeb_Kto_Nr.MaxLength = 50;
                this.columnName.MaxLength = 500;
                this.columnOrt.MaxLength = 200;
                this.columnLastChanged.MaxLength = 50;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_HeaderRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_BMW_Bank_HeaderDataTable tableTAB_BMW_Bank_Header;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_BMW_Bank_HeaderRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_BMW_Bank_Header = (TAB_BMW_Bank_HeaderDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public long BMW_Header_ID
            {
                get
                {
                    return Conversions.ToLong(this[this.tableTAB_BMW_Bank_Header.BMW_Header_IDColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Header.BMW_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Deb_Kto_Nr
            {
                get
                {
                    if (this.IsDeb_Kto_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Header.Deb_Kto_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Header.Deb_Kto_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FileName
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_BMW_Bank_Header.FileNameColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FileName in Tabelle TAB_BMW_Bank_Header ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Header.FileNameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string LastChanged
            {
                get
                {
                    if (this.IsLastChangedNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Header.LastChangedColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Header.LastChangedColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_BMW_Bank_Header.NameColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Name in Tabelle TAB_BMW_Bank_Header ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Header.NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Ort
            {
                get
                {
                    if (this.IsOrtNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Header.OrtColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Header.OrtColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Typ
            {
                get
                {
                    if (this.IsTypNull())
                    {
                        return null;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Bank_Header.TypColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Bank_Header.TypColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_DetailsRow[] GetTAB_BMW_Bank_DetailsRows()
            {
                if (this.Table.ChildRelations["TAB_BMW_Header_TAB_BMW_Detail"] == null)
                {
                    return new TAB_BMW_Bank_DetailsRow[0];
                }
                return
                    (TAB_BMW_Bank_DetailsRow[])
                    base.GetChildRows(this.Table.ChildRelations["TAB_BMW_Header_TAB_BMW_Detail"]);
            }

            [DebuggerNonUserCode]
            public bool IsDeb_Kto_NrNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Header.Deb_Kto_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFileNameNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Header.FileNameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsLastChangedNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Header.LastChangedColumn);
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Header.NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsOrtNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Header.OrtColumn);
            }

            [DebuggerNonUserCode]
            public bool IsTypNull()
            {
                return this.IsNull(this.tableTAB_BMW_Bank_Header.TypColumn);
            }

            [DebuggerNonUserCode]
            public void SetDeb_Kto_NrNull()
            {
                this[this.tableTAB_BMW_Bank_Header.Deb_Kto_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFileNameNull()
            {
                this[this.tableTAB_BMW_Bank_Header.FileNameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetLastChangedNull()
            {
                this[this.tableTAB_BMW_Bank_Header.LastChangedColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                this[this.tableTAB_BMW_Bank_Header.NameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetOrtNull()
            {
                this[this.tableTAB_BMW_Bank_Header.OrtColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetTypNull()
            {
                this[this.tableTAB_BMW_Bank_Header.TypColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_Bank_HeaderRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_BMW_Bank_HeaderRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderRowChangeEvent(TAB_BMW_Bank_HeaderRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_BMW_Bank_HeaderRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_DebitorenkontenDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnAbrufen;

            private DataColumn columnBezeichnung;

            private DataColumn columnDeb_Kto_Nr;

            private DataColumn columnID;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_DebitorenkontenDataTable()
            {
                this.TableName = "TAB_BMW_Debitorenkonten";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_BMW_DebitorenkontenDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_BMW_DebitorenkontenDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

         

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn AbrufenColumn
            {
                get
                {
                    return this.columnAbrufen;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn BezeichnungColumn
            {
                get
                {
                    return this.columnBezeichnung;
                }
            }

            [DebuggerNonUserCode]
            [Browsable(false)]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Deb_Kto_NrColumn
            {
                get
                {
                    return this.columnDeb_Kto_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn IDColumn
            {
                get
                {
                    return this.columnID;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_BMW_DebitorenkontenRow this[int index]
            {
                get
                {
                    return (TAB_BMW_DebitorenkontenRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_BMW_DebitorenkontenDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_BMW_DebitorenkontenRow(TAB_BMW_DebitorenkontenRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_BMW_DebitorenkontenRow AddTAB_BMW_DebitorenkontenRow(
                string Bezeichnung, long Deb_Kto_Nr, bool Abrufen)
            {
                var row = (TAB_BMW_DebitorenkontenRow)this.NewRow();
                row.ItemArray = new object[] { null, Bezeichnung, Deb_Kto_Nr, Abrufen };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_BMW_DebitorenkontenDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public TAB_BMW_DebitorenkontenRow FindByID(int ID)
            {
                return (TAB_BMW_DebitorenkontenRow)this.Rows.Find(new object[] { ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_BMW_DebitorenkontenRow NewTAB_BMW_DebitorenkontenRow()
            {
                return (TAB_BMW_DebitorenkontenRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_BMW_DebitorenkontenRow(TAB_BMW_DebitorenkontenRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnID = base.Columns["ID"];
                this.columnBezeichnung = base.Columns["Bezeichnung"];
                this.columnDeb_Kto_Nr = base.Columns["Deb_Kto_Nr"];
                this.columnAbrufen = base.Columns["Abrufen"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_BMW_DebitorenkontenDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_BMW_DebitorenkontenRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_BMW_DebitorenkontenRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_BMW_DebitorenkontenRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEventHandler handler = this.TAB_BMW_DebitorenkontenRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEvent((DatenschemaBMW.TAB_BMW_DebitorenkontenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_BMW_DebitorenkontenRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEventHandler handler = this.TAB_BMW_DebitorenkontenRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEvent((DatenschemaBMW.TAB_BMW_DebitorenkontenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_BMW_DebitorenkontenRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEventHandler handler = this.TAB_BMW_DebitorenkontenRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEvent((DatenschemaBMW.TAB_BMW_DebitorenkontenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_BMW_DebitorenkontenRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEventHandler handler = this.TAB_BMW_DebitorenkontenRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BMW_DebitorenkontenRowChangeEvent((DatenschemaBMW.TAB_BMW_DebitorenkontenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnID = new DataColumn("ID", typeof(int), null, MappingType.Element);
                base.Columns.Add(this.columnID);
                this.columnBezeichnung = new DataColumn("Bezeichnung", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBezeichnung);
                this.columnDeb_Kto_Nr = new DataColumn("Deb_Kto_Nr", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnDeb_Kto_Nr);
                this.columnAbrufen = new DataColumn("Abrufen", typeof(bool), null, MappingType.Element);
                base.Columns.Add(this.columnAbrufen);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new[] { this.columnID }, true));
                this.columnID.AutoIncrement = true;
                this.columnID.AllowDBNull = false;
                this.columnID.Unique = true;
                this.columnBezeichnung.MaxLength = 0x19;
                this.columnAbrufen.DefaultValue = true;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_DebitorenkontenRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_BMW_DebitorenkontenDataTable tableTAB_BMW_Debitorenkonten;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_BMW_DebitorenkontenRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_BMW_Debitorenkonten = (TAB_BMW_DebitorenkontenDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public bool Abrufen
            {
                get
                {
                    bool flag;
                    try
                    {
                        flag = Conversions.ToBoolean(this[this.tableTAB_BMW_Debitorenkonten.AbrufenColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Abrufen in Tabelle TAB_BMW_Debitorenkonten ist DBNull.", innerException);
                    }
                    return flag;
                }
                set
                {
                    this[this.tableTAB_BMW_Debitorenkonten.AbrufenColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Bezeichnung
            {
                get
                {
                    if (this.IsBezeichnungNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_BMW_Debitorenkonten.BezeichnungColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Debitorenkonten.BezeichnungColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long Deb_Kto_Nr
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_BMW_Debitorenkonten.Deb_Kto_NrColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Deb_Kto_Nr in Tabelle TAB_BMW_Debitorenkonten ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_BMW_Debitorenkonten.Deb_Kto_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public int ID
            {
                get
                {
                    return Conversions.ToInteger(this[this.tableTAB_BMW_Debitorenkonten.IDColumn]);
                }
                set
                {
                    this[this.tableTAB_BMW_Debitorenkonten.IDColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsAbrufenNull()
            {
                return this.IsNull(this.tableTAB_BMW_Debitorenkonten.AbrufenColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBezeichnungNull()
            {
                return this.IsNull(this.tableTAB_BMW_Debitorenkonten.BezeichnungColumn);
            }

            [DebuggerNonUserCode]
            public bool IsDeb_Kto_NrNull()
            {
                return this.IsNull(this.tableTAB_BMW_Debitorenkonten.Deb_Kto_NrColumn);
            }

            [DebuggerNonUserCode]
            public void SetAbrufenNull()
            {
                this[this.tableTAB_BMW_Debitorenkonten.AbrufenColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBezeichnungNull()
            {
                this[this.tableTAB_BMW_Debitorenkonten.BezeichnungColumn] = RuntimeHelpers.GetObjectValue(
                    Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetDeb_Kto_NrNull()
            {
                this[this.tableTAB_BMW_Debitorenkonten.Deb_Kto_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BMW_DebitorenkontenRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_BMW_DebitorenkontenRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BMW_DebitorenkontenRowChangeEvent(TAB_BMW_DebitorenkontenRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_BMW_DebitorenkontenRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BemerkungenDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnBemerkung;

            private DataColumn columnFGST_Nr;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BemerkungenDataTable()
            {
                this.TableName = "TAB_Bemerkungen";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_BemerkungenDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_BemerkungenDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn BemerkungColumn
            {
                get
                {
                    return this.columnBemerkung;
                }
            }

            [DebuggerNonUserCode]
            [Browsable(false)]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_BemerkungenRow this[int index]
            {
                get
                {
                    return (TAB_BemerkungenRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_BemerkungenDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_BemerkungenRow(TAB_BemerkungenRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_BemerkungenRow AddTAB_BemerkungenRow(string FGST_Nr, string Bemerkung)
            {
                var row = (TAB_BemerkungenRow)this.NewRow();
                row.ItemArray = new object[] { FGST_Nr, Bemerkung };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_BemerkungenDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_BemerkungenRow NewTAB_BemerkungenRow()
            {
                return (TAB_BemerkungenRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_BemerkungenRow(TAB_BemerkungenRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnBemerkung = base.Columns["Bemerkung"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_BemerkungenDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_BemerkungenRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_BemerkungenRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_BemerkungenRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BemerkungenRowChangeEventHandler handler = this.TAB_BemerkungenRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BemerkungenRowChangeEvent((DatenschemaBMW.TAB_BemerkungenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_BemerkungenRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BemerkungenRowChangeEventHandler handler = this.TAB_BemerkungenRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BemerkungenRowChangeEvent((DatenschemaBMW.TAB_BemerkungenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_BemerkungenRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_BemerkungenRowChangeEventHandler handler = this.TAB_BemerkungenRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BemerkungenRowChangeEvent((DatenschemaBMW.TAB_BemerkungenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_BemerkungenRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_BemerkungenRowChangeEventHandler handler = this.TAB_BemerkungenRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_BemerkungenRowChangeEvent((DatenschemaBMW.TAB_BemerkungenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnBemerkung = new DataColumn("Bemerkung", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBemerkung);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new[] { this.columnFGST_Nr }, false));
                this.columnFGST_Nr.AllowDBNull = false;
                this.columnFGST_Nr.Unique = true;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BemerkungenRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_BemerkungenDataTable tableTAB_Bemerkungen;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_BemerkungenRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_Bemerkungen = (TAB_BemerkungenDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public string Bemerkung
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_Bemerkungen.BemerkungColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bemerkung in Tabelle TAB_Bemerkungen ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_Bemerkungen.BemerkungColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    return Conversions.ToString(this[this.tableTAB_Bemerkungen.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Bemerkungen.FGST_NrColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsBemerkungNull()
            {
                return this.IsNull(this.tableTAB_Bemerkungen.BemerkungColumn);
            }

            [DebuggerNonUserCode]
            public void SetBemerkungNull()
            {
                this[this.tableTAB_Bemerkungen.BemerkungColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_BemerkungenRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_BemerkungenRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_BemerkungenRowChangeEvent(TAB_BemerkungenRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_BemerkungenRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Bestand_DetailsDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn _columnEK_Preis;

            private DataColumn columnBemerkung;

            private DataColumn columnBestand_Detail_ID;

            private DataColumn columnBestand_Header_ID;

            private DataColumn columnDatum;

            private DataColumn columnFGST_Nr;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_Bestand_DetailsDataTable()
            {
                this.TableName = "TAB_Bestand_Details";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_Bestand_DetailsDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_Bestand_DetailsDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

           

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn BemerkungColumn
            {
                get
                {
                    return this.columnBemerkung;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Bestand_Detail_IDColumn
            {
                get
                {
                    return this.columnBestand_Detail_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Bestand_Header_IDColumn
            {
                get
                {
                    return this.columnBestand_Header_ID;
                }
            }

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn DatumColumn
            {
                get
                {
                    return this.columnDatum;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn _EK_PreisColumn
            {
                get
                {
                    return this._columnEK_Preis;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_Bestand_DetailsRow this[int index]
            {
                get
                {
                    return (TAB_Bestand_DetailsRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_Bestand_DetailsDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_Bestand_DetailsRow(TAB_Bestand_DetailsRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_Bestand_DetailsRow AddTAB_Bestand_DetailsRow(
                TAB_Bestand_HeaderRow parentTAB_Bestand_HeaderRowByTAB_Bestand_Header_TAB_Bestand_Details,
                string FGST_Nr,
                DateTime Datum,
                double _EK_Preis,
                string Bemerkung)
            {
                var row = (TAB_Bestand_DetailsRow)this.NewRow();
                var objArray = new object[] { null, null, FGST_Nr, Datum, _EK_Preis, Bemerkung };
                if (parentTAB_Bestand_HeaderRowByTAB_Bestand_Header_TAB_Bestand_Details != null)
                {
                    objArray[0] =
                        RuntimeHelpers.GetObjectValue(
                            parentTAB_Bestand_HeaderRowByTAB_Bestand_Header_TAB_Bestand_Details[0]);
                }
                row.ItemArray = objArray;
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_Bestand_DetailsDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_Bestand_DetailsRow NewTAB_Bestand_DetailsRow()
            {
                return (TAB_Bestand_DetailsRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_Bestand_DetailsRow(TAB_Bestand_DetailsRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnBestand_Header_ID = base.Columns["Bestand_Header_ID"];
                this.columnBestand_Detail_ID = base.Columns["Bestand_Detail_ID"];
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnDatum = base.Columns["Datum"];
                this._columnEK_Preis = base.Columns["EK-Preis"];
                this.columnBemerkung = base.Columns["Bemerkung"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_Bestand_DetailsDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_Bestand_DetailsRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_Bestand_DetailsRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_Bestand_DetailsRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_DetailsRowChangeEventHandler handler = this.TAB_Bestand_DetailsRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_DetailsRowChangeEvent((DatenschemaBMW.TAB_Bestand_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_Bestand_DetailsRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_DetailsRowChangeEventHandler handler = this.TAB_Bestand_DetailsRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_DetailsRowChangeEvent((DatenschemaBMW.TAB_Bestand_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_Bestand_DetailsRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_DetailsRowChangeEventHandler handler = this.TAB_Bestand_DetailsRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_DetailsRowChangeEvent((DatenschemaBMW.TAB_Bestand_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_Bestand_DetailsRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_DetailsRowChangeEventHandler handler = this.TAB_Bestand_DetailsRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_DetailsRowChangeEvent((DatenschemaBMW.TAB_Bestand_DetailsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnBestand_Header_ID = new DataColumn(
                    "Bestand_Header_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnBestand_Header_ID);
                this.columnBestand_Detail_ID = new DataColumn(
                    "Bestand_Detail_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnBestand_Detail_ID);
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnDatum = new DataColumn("Datum", typeof(DateTime), null, MappingType.Element);
                base.Columns.Add(this.columnDatum);
                this._columnEK_Preis = new DataColumn("EK-Preis", typeof(double), null, MappingType.Element);
                this._columnEK_Preis.ExtendedProperties.Add("Generator_ColumnVarNameInTable", "_columnEK_Preis");
                this._columnEK_Preis.ExtendedProperties.Add("Generator_UserColumnName", "EK-Preis");
                base.Columns.Add(this._columnEK_Preis);
                this.columnBemerkung = new DataColumn("Bemerkung", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBemerkung);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new[] { this.columnBestand_Detail_ID }, false));
                this.columnBestand_Detail_ID.AutoIncrement = true;
                this.columnBestand_Detail_ID.AutoIncrementSeed = 1L;
                this.columnBestand_Detail_ID.Unique = true;
                this.columnFGST_Nr.MaxLength = 40;
                this.columnBemerkung.DefaultValue = "";
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Bestand_DetailsRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_Bestand_DetailsDataTable tableTAB_Bestand_Details;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_Bestand_DetailsRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_Bestand_Details = (TAB_Bestand_DetailsDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public string Bemerkung
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_Bestand_Details.BemerkungColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bemerkung in Tabelle TAB_Bestand_Details ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_Bestand_Details.BemerkungColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long Bestand_Detail_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_Bestand_Details.Bestand_Detail_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bestand_Detail_ID in Tabelle TAB_Bestand_Details ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Bestand_Details.Bestand_Detail_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long Bestand_Header_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_Bestand_Details.Bestand_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bestand_Header_ID in Tabelle TAB_Bestand_Details ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Bestand_Details.Bestand_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public DateTime Datum
            {
                get
                {
                    DateTime time;
                    try
                    {
                        time = Conversions.ToDate(this[this.tableTAB_Bestand_Details.DatumColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Datum in Tabelle TAB_Bestand_Details ist DBNull.", innerException);
                    }
                    return time;
                }
                set
                {
                    this[this.tableTAB_Bestand_Details.DatumColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    if (this.IsFGST_NrNull())
                    {
                        return "(Empty)";
                    }
                    return Conversions.ToString(this[this.tableTAB_Bestand_Details.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Bestand_Details.FGST_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public TAB_Bestand_HeaderRow TAB_Bestand_HeaderRow
            {
                get
                {
                    return
                        (TAB_Bestand_HeaderRow)
                        this.GetParentRow(this.Table.ParentRelations["TAB_Bestand_Header_TAB_Bestand_Details"]);
                }
                set
                {
                    this.SetParentRow(value, this.Table.ParentRelations["TAB_Bestand_Header_TAB_Bestand_Details"]);
                }
            }

            [DebuggerNonUserCode]
            public double _EK_Preis
            {
                get
                {
                    double num;
                    try
                    {
                        num = Conversions.ToDouble(this[this.tableTAB_Bestand_Details._EK_PreisColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte EK-Preis in Tabelle TAB_Bestand_Details ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Bestand_Details._EK_PreisColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsBemerkungNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Details.BemerkungColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBestand_Detail_IDNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Details.Bestand_Detail_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsBestand_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Details.Bestand_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsDatumNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Details.DatumColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFGST_NrNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Details.FGST_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool Is_EK_PreisNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Details._EK_PreisColumn);
            }

            [DebuggerNonUserCode]
            public void SetBemerkungNull()
            {
                this[this.tableTAB_Bestand_Details.BemerkungColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBestand_Detail_IDNull()
            {
                this[this.tableTAB_Bestand_Details.Bestand_Detail_IDColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetBestand_Header_IDNull()
            {
                this[this.tableTAB_Bestand_Details.Bestand_Header_IDColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetDatumNull()
            {
                this[this.tableTAB_Bestand_Details.DatumColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFGST_NrNull()
            {
                this[this.tableTAB_Bestand_Details.FGST_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void Set_EK_PreisNull()
            {
                this[this.tableTAB_Bestand_Details._EK_PreisColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Bestand_DetailsRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_Bestand_DetailsRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_Bestand_DetailsRowChangeEvent(TAB_Bestand_DetailsRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_Bestand_DetailsRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        [XmlSchemaProvider("GetTypedTableSchema")]
        public class TAB_Bestand_HeaderDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnBestand_Header_ID;

            private DataColumn columnFileName;

            private DataColumn columnLastChanged;

            private DataColumn columnName;

            private DataColumn columnTyp;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_Bestand_HeaderDataTable()
            {
                this.TableName = "TAB_Bestand_Header";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_Bestand_HeaderDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_Bestand_HeaderDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

         

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn Bestand_Header_IDColumn
            {
                get
                {
                    return this.columnBestand_Header_ID;
                }
            }

            [DebuggerNonUserCode]
            [Browsable(false)]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FileNameColumn
            {
                get
                {
                    return this.columnFileName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn LastChangedColumn
            {
                get
                {
                    return this.columnLastChanged;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn TypColumn
            {
                get
                {
                    return this.columnTyp;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_Bestand_HeaderRow this[int index]
            {
                get
                {
                    return (TAB_Bestand_HeaderRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_Bestand_HeaderDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_Bestand_HeaderRow(TAB_Bestand_HeaderRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_Bestand_HeaderRow AddTAB_Bestand_HeaderRow(
                string FileName, string Typ, string Name, string LastChanged)
            {
                var row = (TAB_Bestand_HeaderRow)this.NewRow();
                row.ItemArray = new object[] { null, FileName, Typ, Name, LastChanged };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_Bestand_HeaderDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_Bestand_HeaderRow NewTAB_Bestand_HeaderRow()
            {
                return (TAB_Bestand_HeaderRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_Bestand_HeaderRow(TAB_Bestand_HeaderRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnBestand_Header_ID = base.Columns["Bestand_Header_ID"];
                this.columnFileName = base.Columns["FileName"];
                this.columnTyp = base.Columns["Typ"];
                this.columnName = base.Columns["Name"];
                this.columnLastChanged = base.Columns["LastChanged"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_Bestand_HeaderDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_Bestand_HeaderRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_Bestand_HeaderRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_Bestand_HeaderRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_HeaderRowChangeEventHandler handler = this.TAB_Bestand_HeaderRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_HeaderRowChangeEvent((DatenschemaBMW.TAB_Bestand_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_Bestand_HeaderRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_HeaderRowChangeEventHandler handler = this.TAB_Bestand_HeaderRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_HeaderRowChangeEvent((DatenschemaBMW.TAB_Bestand_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_Bestand_HeaderRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_HeaderRowChangeEventHandler handler = this.TAB_Bestand_HeaderRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_HeaderRowChangeEvent((DatenschemaBMW.TAB_Bestand_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_Bestand_HeaderRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_Bestand_HeaderRowChangeEventHandler handler = this.TAB_Bestand_HeaderRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_Bestand_HeaderRowChangeEvent((DatenschemaBMW.TAB_Bestand_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnBestand_Header_ID = new DataColumn(
                    "Bestand_Header_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnBestand_Header_ID);
                this.columnFileName = new DataColumn("FileName", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFileName);
                this.columnTyp = new DataColumn("Typ", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnTyp);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                this.columnLastChanged = new DataColumn("LastChanged", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnLastChanged);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new[] { this.columnBestand_Header_ID }, false));
                this.columnBestand_Header_ID.AutoIncrement = true;
                this.columnBestand_Header_ID.AutoIncrementSeed = 1L;
                this.columnBestand_Header_ID.Unique = true;
                this.columnFileName.MaxLength = 500;
                this.columnName.MaxLength = 500;
                this.columnLastChanged.MaxLength = 50;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Bestand_HeaderRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_Bestand_HeaderDataTable tableTAB_Bestand_Header;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_Bestand_HeaderRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_Bestand_Header = (TAB_Bestand_HeaderDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public long Bestand_Header_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_Bestand_Header.Bestand_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bestand_Header_ID in Tabelle TAB_Bestand_Header ist DBNull.",
                            innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Bestand_Header.Bestand_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FileName
            {
                get
                {
                    if (this.IsFileNameNull())
                    {
                        return "(Empty)";
                    }
                    return Conversions.ToString(this[this.tableTAB_Bestand_Header.FileNameColumn]);
                }
                set
                {
                    this[this.tableTAB_Bestand_Header.FileNameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string LastChanged
            {
                get
                {
                    if (this.IsLastChangedNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Bestand_Header.LastChangedColumn]);
                }
                set
                {
                    this[this.tableTAB_Bestand_Header.LastChangedColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_Bestand_Header.NameColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Name in Tabelle TAB_Bestand_Header ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_Bestand_Header.NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Typ
            {
                get
                {
                    if (this.IsTypNull())
                    {
                        return "(Nichts)";
                    }
                    return Conversions.ToString(this[this.tableTAB_Bestand_Header.TypColumn]);
                }
                set
                {
                    this[this.tableTAB_Bestand_Header.TypColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public TAB_Bestand_DetailsRow[] GetTAB_Bestand_DetailsRows()
            {
                if (this.Table.ChildRelations["TAB_Bestand_Header_TAB_Bestand_Details"] == null)
                {
                    return new TAB_Bestand_DetailsRow[0];
                }
                return
                    (TAB_Bestand_DetailsRow[])
                    base.GetChildRows(this.Table.ChildRelations["TAB_Bestand_Header_TAB_Bestand_Details"]);
            }

            [DebuggerNonUserCode]
            public bool IsBestand_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Header.Bestand_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFileNameNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Header.FileNameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsLastChangedNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Header.LastChangedColumn);
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Header.NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsTypNull()
            {
                return this.IsNull(this.tableTAB_Bestand_Header.TypColumn);
            }

            [DebuggerNonUserCode]
            public void SetBestand_Header_IDNull()
            {
                this[this.tableTAB_Bestand_Header.Bestand_Header_IDColumn] =
                    RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFileNameNull()
            {
                this[this.tableTAB_Bestand_Header.FileNameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetLastChangedNull()
            {
                this[this.tableTAB_Bestand_Header.LastChangedColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                this[this.tableTAB_Bestand_Header.NameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetTypNull()
            {
                this[this.tableTAB_Bestand_Header.TypColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_Bestand_HeaderRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_Bestand_HeaderRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_Bestand_HeaderRowChangeEvent(TAB_Bestand_HeaderRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_Bestand_HeaderRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_DauerFAsDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnFA_ID;

            private DataColumn columnFGST_Nr;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_DauerFAsDataTable()
            {
                this.TableName = "TAB_DauerFAs";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_DauerFAsDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_DauerFAsDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion


            #region Public Properties

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_IDColumn
            {
                get
                {
                    return this.columnFA_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_DauerFAsRow this[int index]
            {
                get
                {
                    return (TAB_DauerFAsRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_DauerFAsDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_DauerFAsRow(TAB_DauerFAsRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_DauerFAsRow AddTAB_DauerFAsRow(string FGST_Nr, string FA_ID)
            {
                var row = (TAB_DauerFAsRow)this.NewRow();
                row.ItemArray = new object[] { FGST_Nr, FA_ID };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_DauerFAsDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_DauerFAsRow NewTAB_DauerFAsRow()
            {
                return (TAB_DauerFAsRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_DauerFAsRow(TAB_DauerFAsRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnFA_ID = base.Columns["FA_ID"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_DauerFAsDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_DauerFAsRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_DauerFAsRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_DauerFAsRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_DauerFAsRowChangeEventHandler handler = this.TAB_DauerFAsRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_DauerFAsRowChangeEvent((DatenschemaBMW.TAB_DauerFAsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_DauerFAsRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_DauerFAsRowChangeEventHandler handler = this.TAB_DauerFAsRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_DauerFAsRowChangeEvent((DatenschemaBMW.TAB_DauerFAsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_DauerFAsRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_DauerFAsRowChangeEventHandler handler = this.TAB_DauerFAsRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_DauerFAsRowChangeEvent((DatenschemaBMW.TAB_DauerFAsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_DauerFAsRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_DauerFAsRowChangeEventHandler handler = this.TAB_DauerFAsRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_DauerFAsRowChangeEvent((DatenschemaBMW.TAB_DauerFAsRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnFA_ID = new DataColumn("FA_ID", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFA_ID);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new[] { this.columnFGST_Nr }, false));
                this.columnFGST_Nr.AllowDBNull = false;
                this.columnFGST_Nr.Unique = true;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_DauerFAsRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_DauerFAsDataTable tableTAB_DauerFAs;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_DauerFAsRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_DauerFAs = (TAB_DauerFAsDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public string FA_ID
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_DauerFAs.FA_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FA_ID in Tabelle TAB_DauerFAs ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_DauerFAs.FA_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    return Conversions.ToString(this[this.tableTAB_DauerFAs.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_DauerFAs.FGST_NrColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsFA_IDNull()
            {
                return this.IsNull(this.tableTAB_DauerFAs.FA_IDColumn);
            }

            [DebuggerNonUserCode]
            public void SetFA_IDNull()
            {
                this[this.tableTAB_DauerFAs.FA_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_DauerFAsRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_DauerFAsRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_DauerFAsRowChangeEvent(TAB_DauerFAsRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_DauerFAsRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        [XmlSchemaProvider("GetTypedTableSchema")]
        public class TAB_F1_DetailDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnBemerkung;

            private DataColumn columnData_Err;

            private DataColumn columnF1_Detail_ID;

            private DataColumn columnF1_Header_ID;

            private DataColumn columnFGST_Nr;

            private DataColumn columnHasBank;

            private DataColumn columnInterne_Nr;

            private DataColumn columnKunde_Gekauft;

            private DataColumn columnKunden_Nr;

            private DataColumn columnName1;

            private DataColumn columnRE_Dat_VK;

            private DataColumn columnRE_Nr_VK;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_F1_DetailDataTable()
            {
                this.TableName = "TAB_F1_Detail";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_F1_DetailDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_F1_DetailDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

         

            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn BemerkungColumn
            {
                get
                {
                    return this.columnBemerkung;
                }
            }

            [DebuggerNonUserCode]
            [Browsable(false)]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Data_ErrColumn
            {
                get
                {
                    return this.columnData_Err;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn F1_Detail_IDColumn
            {
                get
                {
                    return this.columnF1_Detail_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn F1_Header_IDColumn
            {
                get
                {
                    return this.columnF1_Header_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn HasBankColumn
            {
                get
                {
                    return this.columnHasBank;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Interne_NrColumn
            {
                get
                {
                    return this.columnInterne_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kunde_GekauftColumn
            {
                get
                {
                    return this.columnKunde_Gekauft;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kunden_NrColumn
            {
                get
                {
                    return this.columnKunden_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Name1Column
            {
                get
                {
                    return this.columnName1;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn RE_Dat_VKColumn
            {
                get
                {
                    return this.columnRE_Dat_VK;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn RE_Nr_VKColumn
            {
                get
                {
                    return this.columnRE_Nr_VK;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_F1_DetailRow this[int index]
            {
                get
                {
                    return (TAB_F1_DetailRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_F1_DetailDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_F1_DetailRow(TAB_F1_DetailRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_F1_DetailRow AddTAB_F1_DetailRow(
                TAB_F1_HeaderRow parentTAB_F1_HeaderRowByFK_TAB_F1_Header_TAB_F1_Detail,
                string Interne_Nr,
                string Kunden_Nr,
                string FGST_Nr,
                string Name1,
                DateTime RE_Dat_VK,
                string RE_Nr_VK,
                string Kunde_Gekauft,
                bool Data_Err,
                bool HasBank,
                string Bemerkung)
            {
                var row = (TAB_F1_DetailRow)this.NewRow();
                var objArray = new object[]
                    {
                        null, null, Interne_Nr, Kunden_Nr, FGST_Nr, Name1, RE_Dat_VK, RE_Nr_VK, Kunde_Gekauft, Data_Err,
                        HasBank, Bemerkung
                    };
                if (parentTAB_F1_HeaderRowByFK_TAB_F1_Header_TAB_F1_Detail != null)
                {
                    objArray[1] =
                        RuntimeHelpers.GetObjectValue(parentTAB_F1_HeaderRowByFK_TAB_F1_Header_TAB_F1_Detail[0]);
                }
                row.ItemArray = objArray;
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_F1_DetailDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public TAB_F1_DetailRow FindByF1_Detail_ID(long F1_Detail_ID)
            {
                return (TAB_F1_DetailRow)this.Rows.Find(new object[] { F1_Detail_ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_F1_DetailRow NewTAB_F1_DetailRow()
            {
                return (TAB_F1_DetailRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_F1_DetailRow(TAB_F1_DetailRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnF1_Detail_ID = base.Columns["F1_Detail_ID"];
                this.columnF1_Header_ID = base.Columns["F1_Header_ID"];
                this.columnInterne_Nr = base.Columns["Interne_Nr"];
                this.columnKunden_Nr = base.Columns["Kunden_Nr"];
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnName1 = base.Columns["Name1"];
                this.columnRE_Dat_VK = base.Columns["RE_Dat_VK"];
                this.columnRE_Nr_VK = base.Columns["RE_Nr_VK"];
                this.columnKunde_Gekauft = base.Columns["Kunde_Gekauft"];
                this.columnData_Err = base.Columns["Data_Err"];
                this.columnHasBank = base.Columns["HasBank"];
                this.columnBemerkung = base.Columns["Bemerkung"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_F1_DetailDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_F1_DetailRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_F1_DetailRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_F1_DetailRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_DetailRowChangeEventHandler handler = this.TAB_F1_DetailRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_DetailRowChangeEvent((DatenschemaBMW.TAB_F1_DetailRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_F1_DetailRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_DetailRowChangeEventHandler handler = this.TAB_F1_DetailRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_DetailRowChangeEvent((DatenschemaBMW.TAB_F1_DetailRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_F1_DetailRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_DetailRowChangeEventHandler handler = this.TAB_F1_DetailRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_DetailRowChangeEvent((DatenschemaBMW.TAB_F1_DetailRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_F1_DetailRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_DetailRowChangeEventHandler handler = this.TAB_F1_DetailRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_DetailRowChangeEvent((DatenschemaBMW.TAB_F1_DetailRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnF1_Detail_ID = new DataColumn("F1_Detail_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnF1_Detail_ID);
                this.columnF1_Header_ID = new DataColumn("F1_Header_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnF1_Header_ID);
                this.columnInterne_Nr = new DataColumn("Interne_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnInterne_Nr);
                this.columnKunden_Nr = new DataColumn("Kunden_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKunden_Nr);
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnName1 = new DataColumn("Name1", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName1);
                this.columnRE_Dat_VK = new DataColumn("RE_Dat_VK", typeof(DateTime), null, MappingType.Element);
                base.Columns.Add(this.columnRE_Dat_VK);
                this.columnRE_Nr_VK = new DataColumn("RE_Nr_VK", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnRE_Nr_VK);
                this.columnKunde_Gekauft = new DataColumn("Kunde_Gekauft", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKunde_Gekauft);
                this.columnData_Err = new DataColumn("Data_Err", typeof(bool), null, MappingType.Element);
                base.Columns.Add(this.columnData_Err);
                this.columnHasBank = new DataColumn("HasBank", typeof(bool), null, MappingType.Element);
                base.Columns.Add(this.columnHasBank);
                this.columnBemerkung = new DataColumn("Bemerkung", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBemerkung);
                this.Constraints.Add(new UniqueConstraint("TAB_F1_DetailKey1", new[] { this.columnF1_Detail_ID }, true));
                this.columnF1_Detail_ID.AutoIncrement = true;
                this.columnF1_Detail_ID.AutoIncrementSeed = 1L;
                this.columnF1_Detail_ID.AllowDBNull = false;
                this.columnF1_Detail_ID.Unique = true;
                this.columnInterne_Nr.MaxLength = 20;
                this.columnKunden_Nr.MaxLength = 20;
                this.columnFGST_Nr.MaxLength = 40;
                this.columnName1.MaxLength = 100;
                this.columnRE_Nr_VK.MaxLength = 30;
                this.columnKunde_Gekauft.MaxLength = 30;
                this.columnData_Err.DefaultValue = false;
                this.columnHasBank.DefaultValue = false;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_F1_DetailRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_F1_DetailDataTable tableTAB_F1_Detail;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_F1_DetailRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_F1_Detail = (TAB_F1_DetailDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public string Bemerkung
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_F1_Detail.BemerkungColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Bemerkung in Tabelle TAB_F1_Detail ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_F1_Detail.BemerkungColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public bool Data_Err
            {
                get
                {
                    bool flag;
                    try
                    {
                        flag = Conversions.ToBoolean(this[this.tableTAB_F1_Detail.Data_ErrColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Data_Err in Tabelle TAB_F1_Detail ist DBNull.", innerException);
                    }
                    return flag;
                }
                set
                {
                    this[this.tableTAB_F1_Detail.Data_ErrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long F1_Detail_ID
            {
                get
                {
                    return Conversions.ToLong(this[this.tableTAB_F1_Detail.F1_Detail_IDColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Detail.F1_Detail_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long F1_Header_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_F1_Detail.F1_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte F1_Header_ID in Tabelle TAB_F1_Detail ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_F1_Detail.F1_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    if (this.IsFGST_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Detail.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Detail.FGST_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public bool HasBank
            {
                get
                {
                    bool flag;
                    try
                    {
                        flag = Conversions.ToBoolean(this[this.tableTAB_F1_Detail.HasBankColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte HasBank in Tabelle TAB_F1_Detail ist DBNull.", innerException);
                    }
                    return flag;
                }
                set
                {
                    this[this.tableTAB_F1_Detail.HasBankColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Interne_Nr
            {
                get
                {
                    if (this.IsInterne_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Detail.Interne_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Detail.Interne_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kunde_Gekauft
            {
                get
                {
                    if (this.IsKunde_GekauftNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Detail.Kunde_GekauftColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Detail.Kunde_GekauftColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kunden_Nr
            {
                get
                {
                    if (this.IsKunden_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Detail.Kunden_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Detail.Kunden_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name1
            {
                get
                {
                    if (this.IsName1Null())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Detail.Name1Column]);
                }
                set
                {
                    this[this.tableTAB_F1_Detail.Name1Column] = value;
                }
            }

            [DebuggerNonUserCode]
            public DateTime RE_Dat_VK
            {
                get
                {
                    DateTime time;
                    try
                    {
                        time = Conversions.ToDate(this[this.tableTAB_F1_Detail.RE_Dat_VKColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte RE_Dat_VK in Tabelle TAB_F1_Detail ist DBNull.", innerException);
                    }
                    return time;
                }
                set
                {
                    this[this.tableTAB_F1_Detail.RE_Dat_VKColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string RE_Nr_VK
            {
                get
                {
                    if (this.IsRE_Nr_VKNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Detail.RE_Nr_VKColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Detail.RE_Nr_VKColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public TAB_F1_HeaderRow TAB_F1_HeaderRow
            {
                get
                {
                    return
                        (TAB_F1_HeaderRow)
                        this.GetParentRow(this.Table.ParentRelations["FK_TAB_F1_Header_TAB_F1_Detail"]);
                }
                set
                {
                    this.SetParentRow(value, this.Table.ParentRelations["FK_TAB_F1_Header_TAB_F1_Detail"]);
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsBemerkungNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.BemerkungColumn);
            }

            [DebuggerNonUserCode]
            public bool IsData_ErrNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.Data_ErrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsF1_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.F1_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFGST_NrNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.FGST_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsHasBankNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.HasBankColumn);
            }

            [DebuggerNonUserCode]
            public bool IsInterne_NrNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.Interne_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKunde_GekauftNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.Kunde_GekauftColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKunden_NrNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.Kunden_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsName1Null()
            {
                return this.IsNull(this.tableTAB_F1_Detail.Name1Column);
            }

            [DebuggerNonUserCode]
            public bool IsRE_Dat_VKNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.RE_Dat_VKColumn);
            }

            [DebuggerNonUserCode]
            public bool IsRE_Nr_VKNull()
            {
                return this.IsNull(this.tableTAB_F1_Detail.RE_Nr_VKColumn);
            }

            [DebuggerNonUserCode]
            public void SetBemerkungNull()
            {
                this[this.tableTAB_F1_Detail.BemerkungColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetData_ErrNull()
            {
                this[this.tableTAB_F1_Detail.Data_ErrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetF1_Header_IDNull()
            {
                this[this.tableTAB_F1_Detail.F1_Header_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFGST_NrNull()
            {
                this[this.tableTAB_F1_Detail.FGST_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetHasBankNull()
            {
                this[this.tableTAB_F1_Detail.HasBankColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetInterne_NrNull()
            {
                this[this.tableTAB_F1_Detail.Interne_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKunde_GekauftNull()
            {
                this[this.tableTAB_F1_Detail.Kunde_GekauftColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKunden_NrNull()
            {
                this[this.tableTAB_F1_Detail.Kunden_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetName1Null()
            {
                this[this.tableTAB_F1_Detail.Name1Column] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetRE_Dat_VKNull()
            {
                this[this.tableTAB_F1_Detail.RE_Dat_VKColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetRE_Nr_VKNull()
            {
                this[this.tableTAB_F1_Detail.RE_Nr_VKColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_F1_DetailRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_F1_DetailRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_F1_DetailRowChangeEvent(TAB_F1_DetailRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_F1_DetailRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        [XmlSchemaProvider("GetTypedTableSchema")]
        public class TAB_F1_HeaderDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnF1_Header_ID;

            private DataColumn columnFileName;

            private DataColumn columnLastChanged;

            private DataColumn columnName;

            private DataColumn columnTyp;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_F1_HeaderDataTable()
            {
                this.TableName = "TAB_F1_Header";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_F1_HeaderDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_F1_HeaderDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

          

            #region Public Properties

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn F1_Header_IDColumn
            {
                get
                {
                    return this.columnF1_Header_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FileNameColumn
            {
                get
                {
                    return this.columnFileName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn LastChangedColumn
            {
                get
                {
                    return this.columnLastChanged;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn TypColumn
            {
                get
                {
                    return this.columnTyp;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_F1_HeaderRow this[int index]
            {
                get
                {
                    return (TAB_F1_HeaderRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_F1_HeaderDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_F1_HeaderRow(TAB_F1_HeaderRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_F1_HeaderRow AddTAB_F1_HeaderRow(string FileName, string Name, string Typ, string LastChanged)
            {
                var row = (TAB_F1_HeaderRow)this.NewRow();
                row.ItemArray = new object[] { null, FileName, Name, Typ, LastChanged };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_F1_HeaderDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_F1_HeaderRow NewTAB_F1_HeaderRow()
            {
                return (TAB_F1_HeaderRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_F1_HeaderRow(TAB_F1_HeaderRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnF1_Header_ID = base.Columns["F1_Header_ID"];
                this.columnFileName = base.Columns["FileName"];
                this.columnName = base.Columns["Name"];
                this.columnTyp = base.Columns["Typ"];
                this.columnLastChanged = base.Columns["LastChanged"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_F1_HeaderDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_F1_HeaderRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_F1_HeaderRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_F1_HeaderRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_HeaderRowChangeEventHandler handler = this.TAB_F1_HeaderRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_HeaderRowChangeEvent((DatenschemaBMW.TAB_F1_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_F1_HeaderRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_HeaderRowChangeEventHandler handler = this.TAB_F1_HeaderRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_HeaderRowChangeEvent((DatenschemaBMW.TAB_F1_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_F1_HeaderRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_HeaderRowChangeEventHandler handler = this.TAB_F1_HeaderRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_HeaderRowChangeEvent((DatenschemaBMW.TAB_F1_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_F1_HeaderRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_F1_HeaderRowChangeEventHandler handler = this.TAB_F1_HeaderRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_F1_HeaderRowChangeEvent((DatenschemaBMW.TAB_F1_HeaderRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnF1_Header_ID = new DataColumn("F1_Header_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnF1_Header_ID);
                this.columnFileName = new DataColumn("FileName", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFileName);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                this.columnTyp = new DataColumn("Typ", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnTyp);
                this.columnLastChanged = new DataColumn("LastChanged", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnLastChanged);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new[] { this.columnF1_Header_ID }, false));
                this.columnF1_Header_ID.AutoIncrement = true;
                this.columnF1_Header_ID.AutoIncrementSeed = 1L;
                this.columnF1_Header_ID.Unique = true;
                this.columnFileName.MaxLength = 500;
                this.columnName.MaxLength = 100;
                this.columnLastChanged.MaxLength = 50;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_F1_HeaderRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_F1_HeaderDataTable tableTAB_F1_Header;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_F1_HeaderRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_F1_Header = (TAB_F1_HeaderDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public long F1_Header_ID
            {
                get
                {
                    long num;
                    try
                    {
                        num = Conversions.ToLong(this[this.tableTAB_F1_Header.F1_Header_IDColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte F1_Header_ID in Tabelle TAB_F1_Header ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_F1_Header.F1_Header_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FileName
            {
                get
                {
                    if (this.IsFileNameNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Header.FileNameColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Header.FileNameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string LastChanged
            {
                get
                {
                    if (this.IsLastChangedNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Header.LastChangedColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Header.LastChangedColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    if (this.IsNameNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Header.NameColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Header.NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Typ
            {
                get
                {
                    if (this.IsTypNull())
                    {
                        return null;
                    }
                    return Conversions.ToString(this[this.tableTAB_F1_Header.TypColumn]);
                }
                set
                {
                    this[this.tableTAB_F1_Header.TypColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public TAB_F1_DetailRow[] GetTAB_F1_DetailRows()
            {
                if (this.Table.ChildRelations["FK_TAB_F1_Header_TAB_F1_Detail"] == null)
                {
                    return new TAB_F1_DetailRow[0];
                }
                return
                    (TAB_F1_DetailRow[])base.GetChildRows(this.Table.ChildRelations["FK_TAB_F1_Header_TAB_F1_Detail"]);
            }

            [DebuggerNonUserCode]
            public bool IsF1_Header_IDNull()
            {
                return this.IsNull(this.tableTAB_F1_Header.F1_Header_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFileNameNull()
            {
                return this.IsNull(this.tableTAB_F1_Header.FileNameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsLastChangedNull()
            {
                return this.IsNull(this.tableTAB_F1_Header.LastChangedColumn);
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return this.IsNull(this.tableTAB_F1_Header.NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsTypNull()
            {
                return this.IsNull(this.tableTAB_F1_Header.TypColumn);
            }

            [DebuggerNonUserCode]
            public void SetF1_Header_IDNull()
            {
                this[this.tableTAB_F1_Header.F1_Header_IDColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFileNameNull()
            {
                this[this.tableTAB_F1_Header.FileNameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetLastChangedNull()
            {
                this[this.tableTAB_F1_Header.LastChangedColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                this[this.tableTAB_F1_Header.NameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetTypNull()
            {
                this[this.tableTAB_F1_Header.TypColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_F1_HeaderRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_F1_HeaderRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_F1_HeaderRowChangeEvent(TAB_F1_HeaderRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_F1_HeaderRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [XmlSchemaProvider("GetTypedTableSchema")]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_FinanzArtenDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnFA_Abloesen;

            private DataColumn columnFA_Color;

            private DataColumn columnFA_ID;

            private DataColumn columnFA_KBz;

            private DataColumn columnFA_KundeAuto;

            private DataColumn columnFA_Name;

            private DataColumn columnFA_Tage_Auto;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_FinanzArtenDataTable()
            {
                this.TableName = "TAB_FinanzArten";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_FinanzArtenDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_FinanzArtenDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion

           

            #region Public Properties

            [DebuggerNonUserCode]
            [Browsable(false)]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_AbloesenColumn
            {
                get
                {
                    return this.columnFA_Abloesen;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_ColorColumn
            {
                get
                {
                    return this.columnFA_Color;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_IDColumn
            {
                get
                {
                    return this.columnFA_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_KBzColumn
            {
                get
                {
                    return this.columnFA_KBz;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_KundeAutoColumn
            {
                get
                {
                    return this.columnFA_KundeAuto;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_NameColumn
            {
                get
                {
                    return this.columnFA_Name;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FA_Tage_AutoColumn
            {
                get
                {
                    return this.columnFA_Tage_Auto;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_FinanzArtenRow this[int index]
            {
                get
                {
                    return (TAB_FinanzArtenRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_FinanzArtenDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_FinanzArtenRow(TAB_FinanzArtenRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_FinanzArtenRow AddTAB_FinanzArtenRow(
                string FA_Name,
                string FA_KBz,
                string FA_Color,
                string FA_KundeAuto,
                short FA_Abloesen,
                byte FA_Tage_Auto)
            {
                var row = (TAB_FinanzArtenRow)this.NewRow();
                row.ItemArray = new object[]
                    { null, FA_Name, FA_KBz, FA_Color, FA_KundeAuto, FA_Abloesen, FA_Tage_Auto };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_FinanzArtenDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public TAB_FinanzArtenRow FindByFA_ID(long FA_ID)
            {
                return (TAB_FinanzArtenRow)this.Rows.Find(new object[] { FA_ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_FinanzArtenRow NewTAB_FinanzArtenRow()
            {
                return (TAB_FinanzArtenRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_FinanzArtenRow(TAB_FinanzArtenRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnFA_ID = base.Columns["FA_ID"];
                this.columnFA_Name = base.Columns["FA_Name"];
                this.columnFA_KBz = base.Columns["FA_KBz"];
                this.columnFA_Color = base.Columns["FA_Color"];
                this.columnFA_KundeAuto = base.Columns["FA_KundeAuto"];
                this.columnFA_Abloesen = base.Columns["FA_Abloesen"];
                this.columnFA_Tage_Auto = base.Columns["FA_Tage_Auto"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_FinanzArtenDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_FinanzArtenRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_FinanzArtenRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_FinanzArtenRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_FinanzArtenRowChangeEventHandler handler = this.TAB_FinanzArtenRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_FinanzArtenRowChangeEvent((DatenschemaBMW.TAB_FinanzArtenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_FinanzArtenRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_FinanzArtenRowChangeEventHandler handler = this.TAB_FinanzArtenRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_FinanzArtenRowChangeEvent((DatenschemaBMW.TAB_FinanzArtenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_FinanzArtenRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_FinanzArtenRowChangeEventHandler handler = this.TAB_FinanzArtenRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_FinanzArtenRowChangeEvent((DatenschemaBMW.TAB_FinanzArtenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_FinanzArtenRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_FinanzArtenRowChangeEventHandler handler = this.TAB_FinanzArtenRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_FinanzArtenRowChangeEvent((DatenschemaBMW.TAB_FinanzArtenRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnFA_ID = new DataColumn("FA_ID", typeof(long), null, MappingType.Element);
                base.Columns.Add(this.columnFA_ID);
                this.columnFA_Name = new DataColumn("FA_Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFA_Name);
                this.columnFA_KBz = new DataColumn("FA_KBz", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFA_KBz);
                this.columnFA_Color = new DataColumn("FA_Color", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFA_Color);
                this.columnFA_KundeAuto = new DataColumn("FA_KundeAuto", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFA_KundeAuto);
                this.columnFA_Abloesen = new DataColumn("FA_Abloesen", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnFA_Abloesen);
                this.columnFA_Tage_Auto = new DataColumn("FA_Tage_Auto", typeof(byte), null, MappingType.Element);
                base.Columns.Add(this.columnFA_Tage_Auto);
                this.Constraints.Add(new UniqueConstraint("TAB_FinanzArtenKey1", new[] { this.columnFA_ID }, true));
                this.columnFA_ID.AutoIncrement = true;
                this.columnFA_ID.AutoIncrementSeed = 1L;
                this.columnFA_ID.AllowDBNull = false;
                this.columnFA_ID.Unique = true;
                this.columnFA_Name.MaxLength = 100;
                this.columnFA_KBz.MaxLength = 4;
                this.columnFA_Color.MaxLength = 20;
                this.columnFA_Abloesen.DefaultValue = (short)0;
                this.columnFA_Tage_Auto.DefaultValue = (byte)0;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_FinanzArtenRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_FinanzArtenDataTable tableTAB_FinanzArten;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_FinanzArtenRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_FinanzArten = (TAB_FinanzArtenDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public short FA_Abloesen
            {
                get
                {
                    short num;
                    try
                    {
                        num = Conversions.ToShort(this[this.tableTAB_FinanzArten.FA_AbloesenColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FA_Abloesen in Tabelle TAB_FinanzArten ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_FinanzArten.FA_AbloesenColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FA_Color
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_FinanzArten.FA_ColorColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FA_Color in Tabelle TAB_FinanzArten ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_FinanzArten.FA_ColorColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public long FA_ID
            {
                get
                {
                    return Conversions.ToLong(this[this.tableTAB_FinanzArten.FA_IDColumn]);
                }
                set
                {
                    this[this.tableTAB_FinanzArten.FA_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FA_KBz
            {
                get
                {
                    if (this.IsFA_KBzNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_FinanzArten.FA_KBzColumn]);
                }
                set
                {
                    this[this.tableTAB_FinanzArten.FA_KBzColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FA_KundeAuto
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_FinanzArten.FA_KundeAutoColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FA_KundeAuto in Tabelle TAB_FinanzArten ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_FinanzArten.FA_KundeAutoColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FA_Name
            {
                get
                {
                    string str;
                    try
                    {
                        str = Conversions.ToString(this[this.tableTAB_FinanzArten.FA_NameColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FA_Name in Tabelle TAB_FinanzArten ist DBNull.", innerException);
                    }
                    return str;
                }
                set
                {
                    this[this.tableTAB_FinanzArten.FA_NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public byte FA_Tage_Auto
            {
                get
                {
                    byte num;
                    try
                    {
                        num = Conversions.ToByte(this[this.tableTAB_FinanzArten.FA_Tage_AutoColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte FA_Tage_Auto in Tabelle TAB_FinanzArten ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_FinanzArten.FA_Tage_AutoColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsFA_AbloesenNull()
            {
                return this.IsNull(this.tableTAB_FinanzArten.FA_AbloesenColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_ColorNull()
            {
                return this.IsNull(this.tableTAB_FinanzArten.FA_ColorColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_KBzNull()
            {
                return this.IsNull(this.tableTAB_FinanzArten.FA_KBzColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_KundeAutoNull()
            {
                return this.IsNull(this.tableTAB_FinanzArten.FA_KundeAutoColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_NameNull()
            {
                return this.IsNull(this.tableTAB_FinanzArten.FA_NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFA_Tage_AutoNull()
            {
                return this.IsNull(this.tableTAB_FinanzArten.FA_Tage_AutoColumn);
            }

            [DebuggerNonUserCode]
            public void SetFA_AbloesenNull()
            {
                this[this.tableTAB_FinanzArten.FA_AbloesenColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_ColorNull()
            {
                this[this.tableTAB_FinanzArten.FA_ColorColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_KBzNull()
            {
                this[this.tableTAB_FinanzArten.FA_KBzColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_KundeAutoNull()
            {
                this[this.tableTAB_FinanzArten.FA_KundeAutoColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_NameNull()
            {
                this[this.tableTAB_FinanzArten.FA_NameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFA_Tage_AutoNull()
            {
                this[this.tableTAB_FinanzArten.FA_Tage_AutoColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_FinanzArtenRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_FinanzArtenRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_FinanzArtenRowChangeEvent(TAB_FinanzArtenRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_FinanzArtenRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }

        [Serializable]
        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        [XmlSchemaProvider("GetTypedTableSchema")]
        public class TAB_HistorieDataTable : DataTable, IEnumerable
        {
            #region Constants and Fields

            private DataColumn columnAbloese_Betrag;

            private DataColumn columnAbloese_Datum;

            private DataColumn columnFGST_Nr;

            private DataColumn columnKredit_Nr;

            private DataColumn columnKunden_Nr;

            private DataColumn columnName;

            private DataColumn columnOrt;

            private DataColumn columnRE_Dat_VK;

            private DataColumn columnRE_Nr_VK;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_HistorieDataTable()
            {
                this.TableName = "TAB_Historie";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal TAB_HistorieDataTable(DataTable table)
            {
                this.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    this.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected TAB_HistorieDataTable(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
                this.InitVars();
            }

            #endregion


            #region Public Properties

            [DebuggerNonUserCode]
            public DataColumn Abloese_BetragColumn
            {
                get
                {
                    return this.columnAbloese_Betrag;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Abloese_DatumColumn
            {
                get
                {
                    return this.columnAbloese_Datum;
                }
            }

            [Browsable(false)]
            [DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return this.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn FGST_NrColumn
            {
                get
                {
                    return this.columnFGST_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kredit_NrColumn
            {
                get
                {
                    return this.columnKredit_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn Kunden_NrColumn
            {
                get
                {
                    return this.columnKunden_Nr;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn OrtColumn
            {
                get
                {
                    return this.columnOrt;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn RE_Dat_VKColumn
            {
                get
                {
                    return this.columnRE_Dat_VK;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn RE_Nr_VKColumn
            {
                get
                {
                    return this.columnRE_Nr_VK;
                }
            }

            #endregion

            #region Public Indexers

            [DebuggerNonUserCode]
            public TAB_HistorieRow this[int index]
            {
                get
                {
                    return (TAB_HistorieRow)this.Rows[index];
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                var type2 = new XmlSchemaComplexType();
                var sequence = new XmlSchemaSequence();
                var abmw = new DatenschemaBMW();
                var item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                decimal num = 0M;
                item.MinOccurs = num;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                var any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                num = 1M;
                any2.MinOccurs = num;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                var attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = abmw.Namespace;
                type2.Attributes.Add(attribute);
                var attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "TAB_HistorieDataTable";
                type2.Attributes.Add(attribute2);
                type2.Particle = sequence;
                XmlSchema schemaSerializable = abmw.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    var stream = new MemoryStream();
                    var stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema)enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type2;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type2;
            }

            [DebuggerNonUserCode]
            public void AddTAB_HistorieRow(TAB_HistorieRow row)
            {
                this.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public TAB_HistorieRow AddTAB_HistorieRow(
                string FGST_Nr,
                string Name,
                string Ort,
                string Kredit_Nr,
                decimal Abloese_Betrag,
                DateTime Abloese_Datum,
                string RE_Dat_VK,
                string RE_Nr_VK,
                string Kunden_Nr)
            {
                var row = (TAB_HistorieRow)this.NewRow();
                row.ItemArray = new object[]
                    { FGST_Nr, Name, Ort, Kredit_Nr, Abloese_Betrag, Abloese_Datum, RE_Dat_VK, RE_Nr_VK, Kunden_Nr };
                this.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                var table = (TAB_HistorieDataTable)base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return this.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            public TAB_HistorieRow NewTAB_HistorieRow()
            {
                return (TAB_HistorieRow)this.NewRow();
            }

            [DebuggerNonUserCode]
            public void RemoveTAB_HistorieRow(TAB_HistorieRow row)
            {
                this.Rows.Remove(row);
            }

            #endregion

            #region Methods

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnFGST_Nr = base.Columns["FGST_Nr"];
                this.columnName = base.Columns["Name"];
                this.columnOrt = base.Columns["Ort"];
                this.columnKredit_Nr = base.Columns["Kredit_Nr"];
                this.columnAbloese_Betrag = base.Columns["Abloese_Betrag"];
                this.columnAbloese_Datum = base.Columns["Abloese_Datum"];
                this.columnRE_Dat_VK = base.Columns["RE_Dat_VK"];
                this.columnRE_Nr_VK = base.Columns["RE_Nr_VK"];
                this.columnKunden_Nr = base.Columns["Kunden_Nr"];
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new TAB_HistorieDataTable();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(TAB_HistorieRow);
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new TAB_HistorieRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                //if (this.TAB_HistorieRowChangedEvent != null)
                //{
                //    DatenschemaBMW.TAB_HistorieRowChangeEventHandler handler = this.TAB_HistorieRowChangedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_HistorieRowChangeEvent((DatenschemaBMW.TAB_HistorieRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                //if (this.TAB_HistorieRowChangingEvent != null)
                //{
                //    DatenschemaBMW.TAB_HistorieRowChangeEventHandler handler = this.TAB_HistorieRowChangingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_HistorieRowChangeEvent((DatenschemaBMW.TAB_HistorieRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                //if (this.TAB_HistorieRowDeletedEvent != null)
                //{
                //    DatenschemaBMW.TAB_HistorieRowChangeEventHandler handler = this.TAB_HistorieRowDeletedEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_HistorieRowChangeEvent((DatenschemaBMW.TAB_HistorieRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                //if (this.TAB_HistorieRowDeletingEvent != null)
                //{
                //    DatenschemaBMW.TAB_HistorieRowChangeEventHandler handler = this.TAB_HistorieRowDeletingEvent;
                //    if (handler != null)
                //    {
                //        handler(this, new DatenschemaBMW.TAB_HistorieRowChangeEvent((DatenschemaBMW.TAB_HistorieRow) e.Row, e.Action));
                //    }
                //}
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnFGST_Nr = new DataColumn("FGST_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnFGST_Nr);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                this.columnOrt = new DataColumn("Ort", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnOrt);
                this.columnKredit_Nr = new DataColumn("Kredit_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKredit_Nr);
                this.columnAbloese_Betrag = new DataColumn("Abloese_Betrag", typeof(decimal), null, MappingType.Element);
                base.Columns.Add(this.columnAbloese_Betrag);
                this.columnAbloese_Datum = new DataColumn("Abloese_Datum", typeof(DateTime), null, MappingType.Element);
                base.Columns.Add(this.columnAbloese_Datum);
                this.columnRE_Dat_VK = new DataColumn("RE_Dat_VK", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnRE_Dat_VK);
                this.columnRE_Nr_VK = new DataColumn("RE_Nr_VK", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnRE_Nr_VK);
                this.columnKunden_Nr = new DataColumn("Kunden_Nr", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnKunden_Nr);
                this.columnFGST_Nr.MaxLength = 40;
                this.columnName.MaxLength = 500;
                this.columnOrt.MaxLength = 200;
                this.columnKredit_Nr.MaxLength = 40;
                this.columnAbloese_Betrag.DefaultValue = decimal.Zero;
                this.columnRE_Dat_VK.MaxLength = 20;
                this.columnRE_Nr_VK.MaxLength = 30;
                this.columnKunden_Nr.MaxLength = 20;
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_HistorieRow : DataRow
        {
            #region Constants and Fields

            private readonly TAB_HistorieDataTable tableTAB_Historie;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            internal TAB_HistorieRow(DataRowBuilder rb)
                : base(rb)
            {
                this.tableTAB_Historie = (TAB_HistorieDataTable)this.Table;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public decimal Abloese_Betrag
            {
                get
                {
                    decimal num;
                    try
                    {
                        num = Conversions.ToDecimal(this[this.tableTAB_Historie.Abloese_BetragColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Abloese_Betrag in Tabelle TAB_Historie ist DBNull.", innerException);
                    }
                    return num;
                }
                set
                {
                    this[this.tableTAB_Historie.Abloese_BetragColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public DateTime Abloese_Datum
            {
                get
                {
                    DateTime time;
                    try
                    {
                        time = Conversions.ToDate(this[this.tableTAB_Historie.Abloese_DatumColumn]);
                    }
                    catch (InvalidCastException exception1)
                    {
                        ProjectData.SetProjectError(exception1);
                        InvalidCastException innerException = exception1;
                        throw new StrongTypingException(
                            "Der Wert für Spalte Abloese_Datum in Tabelle TAB_Historie ist DBNull.", innerException);
                    }
                    return time;
                }
                set
                {
                    this[this.tableTAB_Historie.Abloese_DatumColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string FGST_Nr
            {
                get
                {
                    if (this.IsFGST_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Historie.FGST_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Historie.FGST_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kredit_Nr
            {
                get
                {
                    if (this.IsKredit_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Historie.Kredit_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Historie.Kredit_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Kunden_Nr
            {
                get
                {
                    if (this.IsKunden_NrNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Historie.Kunden_NrColumn]);
                }
                set
                {
                    this[this.tableTAB_Historie.Kunden_NrColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    if (this.IsNameNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Historie.NameColumn]);
                }
                set
                {
                    this[this.tableTAB_Historie.NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Ort
            {
                get
                {
                    if (this.IsOrtNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Historie.OrtColumn]);
                }
                set
                {
                    this[this.tableTAB_Historie.OrtColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string RE_Dat_VK
            {
                get
                {
                    if (this.IsRE_Dat_VKNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Historie.RE_Dat_VKColumn]);
                }
                set
                {
                    this[this.tableTAB_Historie.RE_Dat_VKColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string RE_Nr_VK
            {
                get
                {
                    if (this.IsRE_Nr_VKNull())
                    {
                        return string.Empty;
                    }
                    return Conversions.ToString(this[this.tableTAB_Historie.RE_Nr_VKColumn]);
                }
                set
                {
                    this[this.tableTAB_Historie.RE_Nr_VKColumn] = value;
                }
            }

            #endregion

            #region Public Methods and Operators

            [DebuggerNonUserCode]
            public bool IsAbloese_BetragNull()
            {
                return this.IsNull(this.tableTAB_Historie.Abloese_BetragColumn);
            }

            [DebuggerNonUserCode]
            public bool IsAbloese_DatumNull()
            {
                return this.IsNull(this.tableTAB_Historie.Abloese_DatumColumn);
            }

            [DebuggerNonUserCode]
            public bool IsFGST_NrNull()
            {
                return this.IsNull(this.tableTAB_Historie.FGST_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKredit_NrNull()
            {
                return this.IsNull(this.tableTAB_Historie.Kredit_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsKunden_NrNull()
            {
                return this.IsNull(this.tableTAB_Historie.Kunden_NrColumn);
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return this.IsNull(this.tableTAB_Historie.NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsOrtNull()
            {
                return this.IsNull(this.tableTAB_Historie.OrtColumn);
            }

            [DebuggerNonUserCode]
            public bool IsRE_Dat_VKNull()
            {
                return this.IsNull(this.tableTAB_Historie.RE_Dat_VKColumn);
            }

            [DebuggerNonUserCode]
            public bool IsRE_Nr_VKNull()
            {
                return this.IsNull(this.tableTAB_Historie.RE_Nr_VKColumn);
            }

            [DebuggerNonUserCode]
            public void SetAbloese_BetragNull()
            {
                this[this.tableTAB_Historie.Abloese_BetragColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetAbloese_DatumNull()
            {
                this[this.tableTAB_Historie.Abloese_DatumColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetFGST_NrNull()
            {
                this[this.tableTAB_Historie.FGST_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKredit_NrNull()
            {
                this[this.tableTAB_Historie.Kredit_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetKunden_NrNull()
            {
                this[this.tableTAB_Historie.Kunden_NrColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                this[this.tableTAB_Historie.NameColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetOrtNull()
            {
                this[this.tableTAB_Historie.OrtColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetRE_Dat_VKNull()
            {
                this[this.tableTAB_Historie.RE_Dat_VKColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            [DebuggerNonUserCode]
            public void SetRE_Nr_VKNull()
            {
                this[this.tableTAB_Historie.RE_Nr_VKColumn] = RuntimeHelpers.GetObjectValue(Convert.DBNull);
            }

            #endregion
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class TAB_HistorieRowChangeEvent : EventArgs
        {
            #region Constants and Fields

            private readonly DataRowAction eventAction;

            private readonly TAB_HistorieRow eventRow;

            #endregion

            #region Constructors and Destructors

            [DebuggerNonUserCode]
            public TAB_HistorieRowChangeEvent(TAB_HistorieRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            #endregion

            #region Public Properties

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public TAB_HistorieRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }

            #endregion
        }
    }
}